class FeResult(object):
data_size = {'U':3,'S':6,'COORD':3}
re_Skey = re.compile("S[0-5]")
def __init__(self):
self.about = {'creator':GD.Version,
'created':GD.StartTime,
}
self.modeldone = False
self.labels = {}
self.nelems = 0
self.nnodes = 0
self.dofs = None
self.displ = None
self.nodid = None
self.nodes = None
self.elems = None
self.nset = None
self.nsetkey = None
self.eset = None
self.res = None
self.hdr = None
self.nodnr = 0
self.elnr = 0
def datasize(self,key,data):
if FeResult.data_size.has_key(key):
return FeResult.data_size[key]
else:
return len(data)
def Abqver(self,version):
self.about.update({'abqver':version})
def Date(self,date,time):
self.about.update({'abqdate':date,'abqtime':time})
def Size(self,nelems,nnodes,length):
self.nelems = nelems
self.nnodes = nnodes
self.length = length
self.nodid = -ones((nnodes,),dtype=int32)
self.nodes = zeros((nnodes,3),dtype=float32)
self.elems = {}
self.nset = {}
self.eset = {}
def Dofs(self,data):
self.dofs = array(data)
self.displ = self.dofs[self.dofs[:6] > 0]
if self.displ.max() > 3:
self.data_size['U'] = 6
def Heading(self,head):
self.about.update({'heading':head})
def Node(self,nr,coords,normal=None):
self.nodid[self.nodnr] = nr
nn = len(coords)
self.nodes[self.nodnr][:nn] = coords
self.nodnr += 1
def Element(self,nr,typ,conn):
if not self.elems.has_key(typ):
self.elems[typ] = []
self.elems[typ].append(conn)
def Nodeset(self,key,data):
self.nsetkey = key
self.nset[key] = asarray(data)
def NodesetAdd(self,data):
self.nset[self.nsetkey] = union1d(self.nset[self.nsetkey],asarray(data))
def Elemset(self,key,data):
self.esetkey = key
self.eset[key] = asarray(data)
def ElemsetAdd(self,data):
self.eset[self.esetkey] = union1d(self.eset[self.esetkey],asarray(data))
def Finalize(self):
self.nid = connectivity.reverseUniqueIndex(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 Increment(self,step,inc,**kargs):
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 EndIncrement(self):
if not self.modeldone:
self.Finalize()
self.step = self.inc = -1
def Label(self,tag,value):
self.labels[tag] = value
def NodeOutput(self,key,nodid,data):
if not self.R.has_key(key):
self.R[key] = zeros((self.nnodes,self.datasize(key,data)),dtype=float32)
if key == 'U':
self.R[key][nodid-1][self.displ-1] = data
elif key == 'S':
n1 = self.hdr['ndi']
n2 = self.hdr['nshr']
ind = arange(len(data))
ind[n1:] += (3-n1)
#print ind
self.R[key][nodid-1][ind] = data
else:
self.R[key][nodid-1][:len(data)] = data
def ElemHeader(self,**kargs):
self.hdr = dict(**kargs)
def ElemOutput(self,key,data):
if self.hdr['loc'] == 'na':
self.NodeOutput(key,self.hdr['i'],data)
def Export(self):
"""Align on the last increment and export results"""
try:
self.step = self.res.keys()[-1]
self.inc = self.res[self.step].keys()[-1]
self.R = self.res[self.step][self.inc]
except:
self.step = None
self.inc = None
self.R = None
export({'DB':self})
GD.message("Read %d nodes, %d elements" % (self.nnodes,self.nelems))
if self.res is None:
GD.message("No results")
else:
GD.message("Steps: %s" % self.res.keys())
def do_nothing(*arg,**kargs):
"""A do nothing function to stand in for as yet undefined functions."""
pass
TotalEnergies = do_nothing
OutputRequest = do_nothing
Coordinates = do_nothing
Displacements = do_nothing
Unknown = do_nothing
def setStepInc(self,step,inc):
try:
self.step = step
self.inc = inc
self.R = self.res[self.step][self.inc]
except:
self.R = {}
def getSteps(self):
"""Return all the step keys."""
return self.res.keys()
def getIncs(self,step):
"""Return all the incs for given step."""
if self.res.has_key(step):
return self.res[step].keys()
def getres(self,key,domain='nodes'):
"""Return the results of the current step/inc for given key.
The key may include a component to return only a single column
of a multicolumn value.
"""
#print self.dofs
if self.re_Skey.match(key) and self.data_size['S']==3:
components = '013'
else:
components = '012345'
comp = components.find(key[-1])
if comp >= 0:
key = key[:-1]
if self.R.has_key(key):
val = self.R[key]
if comp in range(val.shape[1]):
return val[:,comp]
else:
return val
else:
return None
def printSteps(self):
"""Print the steps/increments/resultcodes for which we have results."""
if self.res is not None:
for i,step in self.res.iteritems():
for j,inc in step.iteritems():
for k,v in inc.iteritems():
print "Step %s, Inc %s, Res %s (%s)" % (i,j,k,str(v.shape))
class FeResult(object):
_name_ = '__FePost__'
re_Skey = re.compile("S[0-5]")
re_Ukey = re.compile("U[0-2]")
def __init__(self,name=_name_,datasize={'U':3,'S':6,'COORD':3}):
self.name = name
self.datasize = datasize.copy()
self.about = {'creator':pf.Version,
'created':pf.StartTime,
}
self.modeldone = False
self.labels = {}
self.nelems = 0
self.nnodes = 0
self.dofs = None
self.displ = None
self.nodid = None
self.nodes = None
self.elems = None
self.nset = None
self.nsetkey = None
self.eset = None
self.res = None
self.hdr = None
self.nodnr = 0
self.elnr = 0
def dataSize(self,key,data):
if key in self.datasize:
return self.datasize[key]
else:
return len(data)
def Abqver(self,version):
self.about.update({'abqver':version})
def Date(self,date,time):
self.about.update({'abqdate':date,'abqtime':time})
def Size(self,nelems,nnodes,length):
self.nelems = nelems
self.nnodes = nnodes
self.length = length
self.nodid = -ones((nnodes,),dtype=int32)
self.nodes = zeros((nnodes,3),dtype=float32)
self.elems = {}
self.nset = {}
self.eset = {}
def Dofs(self,data):
self.dofs = array(data)
self.displ = self.dofs[self.dofs[:6] > 0]
if self.displ.max() > 3:
self.datasize['U'] = 6
def Heading(self,head):
self.about.update({'heading':head})
def Node(self,nr,coords,normal=None):
self.nodid[self.nodnr] = nr
nn = len(coords)
self.nodes[self.nodnr][:nn] = coords
self.nodnr += 1
def Element(self,nr,typ,conn):
if typ not in self.elems:
self.elems[typ] = []
self.elems[typ].append(conn)
def Nodeset(self,key,data):
self.nsetkey = key
self.nset[key] = asarray(data)
def NodesetAdd(self,data):
self.nset[self.nsetkey] = union1d(self.nset[self.nsetkey],asarray(data))
def Elemset(self,key,data):
self.esetkey = key
self.eset[key] = asarray(data)
def ElemsetAdd(self,data):
self.eset[self.esetkey] = union1d(self.eset[self.esetkey],asarray(data))
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 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 EndIncrement(self):
if not self.modeldone:
self.Finalize()
self.step = self.inc = -1
def Label(self,tag,value):
self.labels[tag] = value
def NodeOutput(self,key,nodid,data):
if key not in self.R:
self.R[key] = zeros((self.nnodes,self.dataSize(key,data)),dtype=float32)
if key == 'U':
self.R[key][nodid-1][self.displ-1] = data
elif key == 'S':
n1 = self.hdr['ndi']
n2 = self.hdr['nshr']
ind = arange(len(data))
ind[n1:] += (3-n1)
#print(ind)
self.R[key][nodid-1][ind] = data
else:
self.R[key][nodid-1][:len(data)] = data
def ElemHeader(self,**kargs):
self.hdr = dict(**kargs)
def ElemOutput(self,key,data):
if self.hdr['loc'] == 'na':
self.NodeOutput(key,self.hdr['i'],data)
def Export(self):
"""Align on the last increment and export results"""
try:
self.step = self.res.keys()[-1]
self.inc = self.res[self.step].keys()[-1]
self.R = self.res[self.step][self.inc]
except:
self.step = None
self.inc = None
self.R = None
export({self.name:self, self._name_:self})
pf.message("Read %d nodes, %d elements" % (self.nnodes,self.nelems))
if self.res is None:
pf.message("No results")
else:
pf.message("Steps: %s" % self.res.keys())
def do_nothing(*arg,**kargs):
"""A do nothing function to stand in for as yet undefined functions."""
pass
TotalEnergies = do_nothing
OutputRequest = do_nothing
Coordinates = do_nothing
Displacements = do_nothing
Unknown = do_nothing
def setStepInc(self,step,inc=1):
"""Set the database pointer to a given step,inc pair.
This sets the step and inc attributes to the given values, and puts
the corresponding results in the R attribute. If the step.inc pair does
not exist, an empty results dict is set.
"""
try:
self.step = step
self.inc = inc
self.R = self.res[self.step][self.inc]
except:
self.R = {}
def getSteps(self):
"""Return all the step keys."""
return self.res.keys()
def getIncs(self,step):
"""Return all the incs for given step."""
if step in self.res:
return self.res[step].keys()
def nextStep(self):
"""Skips to the start of the next step."""
if self.step < self.getSteps()[-1]:
self.setStepInc(self.step+1)
def nextInc(self):
"""Skips to the next increment.
The next increment is either the next increment of the current step,
or the first increment of the next step.
"""
if self.inc < self.getIncs(self.step)[-1]:
self.setStepInc(self.step,self.inc+1)
else:
self.nextStep()
def prevStep(self):
"""Skips to the start of the previous step."""
if self.step > 1:
self.setStepInc(self.step-1)
def prevInc(self):
"""Skips to the previous increment.
The previous increment is either the previous increment of the current
step, or the last increment of the previous step.
"""
if self.inc > 1:
self.setStepInc(self.step,self.inc-1)
else:
if self.step > 1:
step = self.step-1
inc = self.getIncs(step)[-1]
self.setStepInc(step,inc)
def getres(self,key,domain='nodes'):
"""Return the results of the current step/inc for given key.
The key may include a component to return only a single column
of a multicolumn value.
"""
components = '012'
if self.re_Skey.match(key):
if self.datasize['S']==3:
components = '013'
else:
components = '012345'
elif self.re_Ukey.match(key):
if self.datasize['U']==2:
components = '01'
else:
components = '012'
comp = components.find(key[-1])
if comp >= 0:
key = key[:-1]
if key in self.R:
val = self.R[key]
if comp in range(val.shape[1]):
return val[:,comp]
else:
return val
else:
return None
def printSteps(self):
"""Print the steps/increments/resultcodes for which we have results."""
if self.res is not None:
for i,step in self.res.iteritems():
for j,inc in step.iteritems():
for k,v in inc.iteritems():
if isinstance(v,ndarray):
data = "%s %s" % (v.dtype.kind,str(v.shape))
else:
data = str(v)
print("Step %s, Inc %s, Res %s (%s)" % (i,j,k,data))
class FeResult(object):
_name_ = '__FePost__'
re_Skey = re.compile("S[0-5]")
re_Ukey = re.compile("U[0-2]")
def __init__(self, name=_name_, datasize={'U': 3, 'S': 6, 'COORD': 3}):
self.name = name
self.datasize = datasize.copy()
self.about = {
'creator': pf.Version,
'created': pf.StartTime,
}
self.modeldone = False
self.labels = {}
self.nelems = 0
self.nnodes = 0
self.dofs = None
self.displ = None
self.nodid = None
self.nodes = None
self.elems = None
self.nset = None
self.nsetkey = None
self.eset = None
self.res = None
self.hdr = None
self.nodnr = 0
self.elnr = 0
def dataSize(self, key, data):
if key in self.datasize:
return self.datasize[key]
else:
return len(data)
def Abqver(self, version):
self.about.update({'abqver': version})
def Date(self, date, time):
self.about.update({'abqdate': date, 'abqtime': time})
def Size(self, nelems, nnodes, length):
self.nelems = nelems
self.nnodes = nnodes
self.length = length
self.nodid = -ones((nnodes, ), dtype=int32)
self.nodes = zeros((nnodes, 3), dtype=float32)
self.elems = {}
self.nset = {}
self.eset = {}
def Dofs(self, data):
self.dofs = array(data)
self.displ = self.dofs[self.dofs[:6] > 0]
if self.displ.max() > 3:
self.datasize['U'] = 6
def Heading(self, head):
self.about.update({'heading': head})
def Node(self, nr, coords, normal=None):
self.nodid[self.nodnr] = nr
nn = len(coords)
self.nodes[self.nodnr][:nn] = coords
self.nodnr += 1
def Element(self, nr, typ, conn):
if typ not in self.elems:
self.elems[typ] = []
self.elems[typ].append(conn)
def Nodeset(self, key, data):
self.nsetkey = key
self.nset[key] = asarray(data)
def NodesetAdd(self, data):
self.nset[self.nsetkey] = union1d(self.nset[self.nsetkey],
asarray(data))
def Elemset(self, key, data):
self.esetkey = key
self.eset[key] = asarray(data)
def ElemsetAdd(self, data):
self.eset[self.esetkey] = union1d(self.eset[self.esetkey],
asarray(data))
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 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 EndIncrement(self):
if not self.modeldone:
self.Finalize()
self.step = self.inc = -1
def Label(self, tag, value):
self.labels[tag] = value
def NodeOutput(self, key, nodid, data):
if key not in self.R:
self.R[key] = zeros((self.nnodes, self.dataSize(key, data)),
dtype=float32)
if key == 'U':
self.R[key][nodid - 1][self.displ - 1] = data
elif key == 'S':
n1 = self.hdr['ndi']
n2 = self.hdr['nshr']
ind = arange(len(data))
ind[n1:] += (3 - n1)
#print(ind)
self.R[key][nodid - 1][ind] = data
else:
self.R[key][nodid - 1][:len(data)] = data
def ElemHeader(self, **kargs):
self.hdr = dict(**kargs)
def ElemOutput(self, key, data):
if self.hdr['loc'] == 'na':
self.NodeOutput(key, self.hdr['i'], data)
def Export(self):
"""Align on the last increment and export results"""
try:
self.step = self.res.keys()[-1]
self.inc = self.res[self.step].keys()[-1]
self.R = self.res[self.step][self.inc]
except:
self.step = None
self.inc = None
self.R = None
export({self.name: self, self._name_: self})
pf.message("Read %d nodes, %d elements" % (self.nnodes, self.nelems))
if self.res is None:
pf.message("No results")
else:
pf.message("Steps: %s" % self.res.keys())
def do_nothing(*arg, **kargs):
"""A do nothing function to stand in for as yet undefined functions."""
pass
TotalEnergies = do_nothing
OutputRequest = do_nothing
Coordinates = do_nothing
Displacements = do_nothing
Unknown = do_nothing
def setStepInc(self, step, inc=1):
"""Set the database pointer to a given step,inc pair.
This sets the step and inc attributes to the given values, and puts
the corresponding results in the R attribute. If the step.inc pair does
not exist, an empty results dict is set.
"""
try:
self.step = step
self.inc = inc
self.R = self.res[self.step][self.inc]
except:
self.R = {}
def getSteps(self):
"""Return all the step keys."""
return self.res.keys()
def getIncs(self, step):
"""Return all the incs for given step."""
if step in self.res:
return self.res[step].keys()
def nextStep(self):
"""Skips to the start of the next step."""
if self.step < self.getSteps()[-1]:
self.setStepInc(self.step + 1)
def nextInc(self):
"""Skips to the next increment.
The next increment is either the next increment of the current step,
or the first increment of the next step.
"""
if self.inc < self.getIncs(self.step)[-1]:
self.setStepInc(self.step, self.inc + 1)
else:
self.nextStep()
def prevStep(self):
"""Skips to the start of the previous step."""
if self.step > 1:
self.setStepInc(self.step - 1)
def prevInc(self):
"""Skips to the previous increment.
The previous increment is either the previous increment of the current
step, or the last increment of the previous step.
"""
if self.inc > 1:
self.setStepInc(self.step, self.inc - 1)
else:
if self.step > 1:
step = self.step - 1
inc = self.getIncs(step)[-1]
self.setStepInc(step, inc)
def getres(self, key, domain='nodes'):
"""Return the results of the current step/inc for given key.
The key may include a component to return only a single column
of a multicolumn value.
"""
components = '012'
if self.re_Skey.match(key):
if self.datasize['S'] == 3:
components = '013'
else:
components = '012345'
elif self.re_Ukey.match(key):
if self.datasize['U'] == 2:
components = '01'
else:
components = '012'
comp = components.find(key[-1])
if comp >= 0:
key = key[:-1]
if key in self.R:
val = self.R[key]
if comp in range(val.shape[1]):
return val[:, comp]
else:
return val
else:
return None
def printSteps(self):
"""Print the steps/increments/resultcodes for which we have results."""
if self.res is not None:
for i, step in self.res.iteritems():
for j, inc in step.iteritems():
for k, v in inc.iteritems():
if isinstance(v, ndarray):
data = "%s %s" % (v.dtype.kind, str(v.shape))
else:
data = str(v)
print("Step %s, Inc %s, Res %s (%s)" % (i, j, k, data))
