renaming of (loosely related) "spectral" scripts to (more tightly related) "geom" versions.

This commit is contained in:
Philip Eisenlohr 2012-11-05 21:19:12 +00:00
parent 639d6e0655
commit 1bd4262cfb
10 changed files with 608 additions and 491 deletions

View File

@ -45,9 +45,9 @@ Changes the (three-dimensional) canvas of a spectral geometry description.
)
parser.add_option('-b', '--box', dest='resolution', type='int', nargs = 3, \
help='resolution of new canvas (a,b,c)')
help='resolution of new canvas (a,b,c) %default')
parser.add_option('-o', '--offset', dest='offset', type='int', nargs = 3, \
help='offset from old to new origin of grid')
help='offset from old to new origin of grid %default')
parser.add_option('-f', '--fill', dest='fill', type='int', \
help='(background) canvas grain index')
parser.add_option('-2', '--twodimensional', dest='twoD', action='store_true', \
@ -64,16 +64,24 @@ parser.set_defaults(fill = 0)
files = []
if filenames == []:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
files.append({'name':'STDIN',
'input':sys.stdin,
'output':sys.stdout,
'croak':sys.stderr,
})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w')})
files.append({'name':name,
'input':open(name),
'output':open(name+'_tmp','w'),
'croak':sys.stdout,
})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
if file['name'] != 'STDIN': print file['name']
if file['name'] != 'STDIN': file['croak'].write(file['name']+'\n')
# get labels by either read the first row, or - if keyword header is present - the last line of the header
@ -88,17 +96,10 @@ for file in files:
content = file['input'].readlines()
file['input'].close()
if 0 in options.resolution:
for header in headers:
headitems = header.split()
if headitems[0] == 'resolution': # located resolution entry
for i in xrange(3):
options.resolution[i] = \
mappings['resolution'](headitems[headitems.index(identifiers['resolution'][i])+1])
info = {'resolution': [0,0,0],
'dimension': [0.0,0.0,0.0],
'origin': [0.0,0.0,0.0],
info = {'resolution': numpy.array(options.resolution),
'dimension': numpy.array([0.0,0.0,0.0]),
'origin': numpy.array([0.0,0.0,0.0]),
'homogenization': 1,
}
@ -113,17 +114,19 @@ for file in files:
else:
info[headitems[0]] = mappings[headitems[0]](headitems[1])
if info['resolution'] == [0,0,0]:
print 'no resolution info found.'
if options.resolution == [0,0,0]:
options.resolution = info['resolution']
if info['resolution'].all() == 0:
file['croak'].write('no resolution info found.\n')
continue
if info['dimension'] == [0.0,0.0,0.0]:
print 'no dimension info found.'
file['croak'].write('no dimension info found.\n')
continue
if file['name'] != 'STDIN':
print 'resolution: %s'%(' x '.join(map(str,info['resolution'])))
print 'dimension: %s'%(' x '.join(map(str,info['dimension'])))
print 'origin: %s'%(' x '.join(map(str,info['origin'])))
file['croak'].write('resolution: %s\n'%(' x '.join(map(str,info['resolution']))) + \
'dimension: %s\n'%(' x '.join(map(str,info['dimension']))) + \
'origin: %s\n'%(' : '.join(map(str,info['origin']))) + \
'homogenization: %i\n'%info['homogenization'])
new_header.append("resolution\ta %i\tb %i\tc %i\n"%(
options.resolution[0],
@ -145,7 +148,7 @@ for file in files:
for item in map(int,line.split()):
microstructure[i%info['resolution'][0],
(i/info['resolution'][0])%info['resolution'][1],
i/info['resolution'][0]/info['resolution'][1]] = item
i/info['resolution'][0] /info['resolution'][1]] = item
i += 1
microstructure_cropped = numpy.zeros(options.resolution,'i')

View File

@ -0,0 +1,232 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os,sys,math,string,re,numpy, damask
from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
# -----------------------------
class extendedOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# --------------------------------------------------------------------
# MAIN
# --------------------------------------------------------------------
identifiers = {
'resolution': ['a','b','c'],
}
mappings = {
'resolution': lambda x: int(x),
'grains': lambda x: int(x),
}
parser = OptionParser(option_class=extendedOption, usage='%prog options [file[s]]', description = """
generates geom file and material_config file using seeds file
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-r', '--resolution', dest='resolution', type='int', nargs = 3, \
help='a,b,c resolution of specimen')
parser.add_option('-d', '--dimension', dest='dimension', type='float', nargs = 3, \
help='x,y,z dimension of specimen')
parser.add_option('--homogenization', dest='homogenization', type='int', \
help='homogenization index to be used')
parser.add_option('--phase', dest='phase', type='int', \
help='phase index to be used')
parser.add_option('-c', '--configuration', dest='config', action='store_true', \
help='output material configuration')
parser.add_option('-2', '--twodimensional', dest='twoD', action='store_true', \
help='output geom file with two-dimensional data arrangement')
parser.set_defaults(resolution = [0,0,0])
parser.set_defaults(dimension = [0.0,0.0,0.0])
parser.set_defaults(homogenization = 1)
parser.set_defaults(phase = 1)
parser.set_defaults(config = False)
parser.set_defaults(twoD = False)
(options,filenames) = parser.parse_args()
# ------------------------------------------ setup file handles ---------------------------------------
files = []
if filenames == []:
files.append({'name':'STDIN',
'input':sys.stdin,
'output':sys.stdout,
'croak':sys.stderr,
})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name,
'input':open(name),
'output':open(name+'_tmp','w'),
'croak':sys.stdout,
})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
if file['name'] != 'STDIN': file['croak'].write(file['name']+'\n')
firstline = file['input'].readline()
m = re.search('(\d+)\s*head', firstline.lower())
if m:
headerlines = int(m.group(1))
headers = [firstline]+[file['input'].readline() for i in range(headerlines)]
else:
headerlines = 1
headers = firstline
content = file['input'].readlines()
file['input'].close()
info = {'grains': 0,
'resolution': numpy.array([0,0,0]),
'dimension': numpy.array(options.dimension),
'origin': numpy.array([0.0,0.0,0.0]),
'homogenization': options.homogenization,
}
new_header = []
for header in headers:
headitems = map(str.lower,header.split())
if headitems[0] in mappings.keys():
if headitems[0] in identifiers.keys():
for i in xrange(len(identifiers[headitems[0]])):
info[headitems[0]][i] = \
mappings[headitems[0]](headitems[headitems.index(identifiers[headitems[0]][i])+1])
else:
info[headitems[0]] = mappings[headitems[0]](headitems[1])
if info['grains'] == 0:
file['croak'].write('no grains found.\n')
continue
if info['grains'] != len(content):
file['croak'].write('grain data not matching grain count...\n')
info['grains'] = min(info['grains'],len(content))
if 0 not in options.resolution: # user-specified resolution
info['resolution'] = numpy.array(options.resolution)
if info['resolution'].all() == 0:
file['croak'].write('no resolution info found.\n')
continue
twoD = info['resolution'][2] < 2
for i in xrange(3):
if info['dimension'][i] <= 0.0: # any invalid dimension?
info['dimension'][i] = float(info['resolution'][i])/max(info['resolution'])
file['croak'].write('rescaling dimension %i...\n'%i)
file['croak'].write('grains: %i\n'%info['grains'] + \
'resolution: %s\n'%(' x '.join(map(str,info['resolution']))) + \
'dimension: %s\n'%(' x '.join(map(str,info['dimension']))) + \
'origin: %s\n'%(' : '.join(map(str,info['origin']))) + \
'homogenization: %i\n'%info['homogenization'])
new_header.append("resolution\ta %i\tb %i\tc %i\n"%(
info['resolution'][0],
info['resolution'][1],
info['resolution'][2],))
new_header.append("dimension\tx %f\ty %f\tz %f\n"%(
info['dimension'][0],
info['dimension'][1],
info['dimension'][2],))
new_header.append("origin\tx %f\ty %f\tz %f\n"%(
info['origin'][0],
info['origin'][1],
info['origin'][2],))
new_header.append("homogenization\t%i\n"%info['homogenization'])
# -------------------------------------- prepare data ----------------------------------
formatwidth = 1+int(math.log10(info['grains']))
coords = numpy.zeros((3,info['grains']),'d')
eulers = numpy.zeros((3,info['grains']),'d')
for i in xrange(info['grains']):
coords[:,i] = map(float,content[i].split()[:3])*info['dimension']
eulers[:,i] = map(float,content[i].split()[3:6])
# -------------------------------------- switch according to task ----------------------------------
if options.config:
file['output'].write('<microstructure>\n')
for i in xrange(info['grains']):
file['output'].write('\n[Grain%s]\n'%(str(i+1).zfill(formatwidth)) + \
'crystallite 1\n' + \
'(constituent)\tphase %i\ttexture %s\tfraction 1.0\n'%(options.phase,str(i+1).rjust(formatwidth)))
file['output'].write('\n<texture>\n')
for i in xrange(info['grains']):
file['output'].write('\n[Grain%s]\n'%(str(i+1).zfill(formatwidth)) + \
'(gauss)\tphi1 %g\tPhi %g\tphi2 %g\tscatter 0.0\tfraction 1.0\n'%(eulers[0,i],eulers[1,i],eulers[2,i]))
else:
file['output'].write('%i\theader\n'%(len(new_header)) + ''.join(new_header))
N = info['resolution'].prod()
shift = 0.5*info['dimension']/info['resolution'] # shift by half of side length to center of element
undeformed = numpy.zeros((3,N),'d')
for i in xrange(N):
undeformed[0,i] = info['dimension'][0]\
* float(i % info['resolution'][0])\
/float(info['resolution'][0])
undeformed[1,i] = info['dimension'][1]\
* float(i//info['resolution'][0] % info['resolution'][1])\
/float(info['resolution'][1])
undeformed[2,i] = info['dimension'][2]\
* float(i//info['resolution'][0]//info['resolution'][1] % info['resolution'][2])\
/float(info['resolution'][2])
undeformed[:,i] += shift
indices = damask.core.math.math_nearestNeighborSearch(3,\
numpy.array(([1.0,0.0,0.0],\
[0.0,1.0,0.0],\
[0.0,0.0,1.0]),'d'),\
info['dimension'],\
N,info['grains'],undeformed,coords)//3**3 + 1 # floor division to kill periodic images
for n in xrange(info['resolution'][1:3].prod()): # loop over 2nd and 3rd dimension
file['output'].write({ True: ' ',
False:'\n'}[options.twoD].\
join(map(lambda x: str(x).rjust(formatwidth),\
indices[n*info['resolution'][0]:(n+1)*info['resolution'][0]]))+'\n')
missing = 0
for i in xrange(info['grains']):
if i+1 not in indices: missing += 1
file['croak'].write({True:'all',False:'only'}[missing == 0] + ' %i grains mapped.\n'%(info['grains']-missing))
# ------------------------------------------ output finalization ---------------------------------------
if file['name'] != 'STDIN':
file['output'].close()
os.rename(file['name']+'_tmp',os.path.splitext(file['name'])[0] + \
{True: '_material.config',
False:'.geom'}[options.config])

179
processing/pre/geom_rescale.py Executable file
View File

@ -0,0 +1,179 @@
#!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*-
import os,sys,string,re,math,numpy
from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
# -----------------------------
class extendedOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# ----------------------- MAIN -------------------------------
identifiers = {
'resolution': ['a','b','c'],
'dimension': ['x','y','z'],
'origin': ['x','y','z'],
}
mappings = {
'resolution': lambda x: int(x),
'dimension': lambda x: float(x),
'origin': lambda x: float(x),
'homogenization': lambda x: int(x),
}
parser = OptionParser(option_class=extendedOption, usage='%prog options [file[s]]', description = """
Scales a geometry description independently in x, y, and z direction in terms of resolution and/or dimension.
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-r', '--resolution', dest='resolution', type='int', nargs = 3, \
help='new resolution (a,b,c)')
parser.add_option('-d', '--dimension', dest='dimension', type='float', nargs = 3, \
help='new dimension (x,y,z)')
parser.add_option('-2', '--twodimensional', dest='twoD', action='store_true', \
help='output geom file with two-dimensional data arrangement')
parser.set_defaults(resolution = [0,0,0])
parser.set_defaults(dimension = [0.0,0.0,0.0])
parser.set_defaults(twoD = False)
(options, filenames) = parser.parse_args()
# ------------------------------------------ setup file handles ---------------------------------------
files = []
if filenames == []:
files.append({'name':'STDIN',
'input':sys.stdin,
'output':sys.stdout,
'croak':sys.stderr,
})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name,
'input':open(name),
'output':open(name+'_tmp','w'),
'croak':sys.stdout,
})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
if file['name'] != 'STDIN': file['croak'].write(file['name']+'\n')
# get labels by either read the first row, or - if keyword header is present - the last line of the header
firstline = file['input'].readline()
m = re.search('(\d+)\s*head', firstline.lower())
if m:
headerlines = int(m.group(1))
headers = [firstline]+[file['input'].readline() for i in range(headerlines)]
else:
headerlines = 1
headers = firstline
content = file['input'].readlines()
file['input'].close()
info = {'resolution': numpy.array(options.resolution),
'dimension': numpy.array(options.dimension),
'origin': numpy.array([0.0,0.0,0.0]),
'homogenization': 1,
}
new_header = []
for header in headers:
headitems = map(str.lower,header.split())
if headitems[0] in mappings.keys():
if headitems[0] in identifiers.keys():
for i in xrange(len(identifiers[headitems[0]])):
info[headitems[0]][i] = \
mappings[headitems[0]](headitems[headitems.index(identifiers[headitems[0]][i])+1])
else:
info[headitems[0]] = mappings[headitems[0]](headitems[1])
if info['resolution'].all() == 0:
file['croak'].write('no resolution info found.\n')
continue
if info['dimension'].all() == 0.0:
file['croak'].write('no dimension info found.\n')
continue
if options.resolution == [0,0,0]:
options.resolution = info['resolution']
if options.dimension == [0.0,0.0,0.0]:
options.dimension = info['dimension']
file['croak'].write('resolution: %s\n'%(' x '.join(map(str,info['resolution']))) + \
'dimension: %s\n'%(' x '.join(map(str,info['dimension']))) + \
'origin: %s\n'%(' : '.join(map(str,info['origin']))) + \
'homogenization: %i\n'%info['homogenization'])
new_header.append("resolution\ta %i\tb %i\tc %i\n"%(
options.resolution[0],
options.resolution[1],
options.resolution[2],))
new_header.append("dimension\tx %f\ty %f\tz %f\n"%(
options.dimension[0],
options.dimension[1],
options.dimension[2],))
new_header.append("origin\tx %f\ty %f\tz %f\n"%(
info['origin'][0],
info['origin'][1],
info['origin'][2],))
new_header.append("homogenization\t%i\n"%info['homogenization'])
microstructure = numpy.zeros(info['resolution'],'i')
i = 0
for line in content:
for item in map(int,line.split()):
microstructure[i%info['resolution'][0],
(i/info['resolution'][0])%info['resolution'][1],
i/info['resolution'][0] /info['resolution'][1]] = item
i += 1
formatwidth = 1+int(math.floor(math.log10(microstructure.max())))
# ------------------------------------------ assemble header ---------------------------------------
output = '%i\theader\n'%(len(new_header))
output += ''.join(new_header)
# ------------------------------------- regenerate texture information ----------------------------------
for c in xrange(options.resolution[2]):
z = int(info['resolution'][2]*(c+0.5)/options.resolution[2])%info['resolution'][2]
for b in xrange(options.resolution[1]):
y = int(info['resolution'][1]*(b+0.5)/options.resolution[1])%info['resolution'][1]
for a in xrange(options.resolution[0]):
x = int(info['resolution'][0]*(a+0.5)/options.resolution[0])%info['resolution'][0]
output += str(microstructure[x,y,z]).rjust(formatwidth) + {True:' ',False:'\n'}[options.twoD]
output += {True:'\n',False:''}[options.twoD]
# ------------------------------------------ output result ---------------------------------------
file['output'].write(output)
file['input'].close()
if file['name'] != 'STDIN':
file['output'].close()

View File

@ -68,16 +68,24 @@ for i in xrange(len(options.substitute)/2):
files = []
if filenames == []:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
files.append({'name':'STDIN',
'input':sys.stdin,
'output':sys.stdout,
'croak':sys.stderr,
})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w')})
files.append({'name':name,
'input':open(name),
'output':open(name+'_tmp','w'),
'croak':sys.stdout,
})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
if file['name'] != 'STDIN': print file['name']
if file['name'] != 'STDIN': file['croak'].write(file['name']+'\n')
# get labels by either read the first row, or - if keyword header is present - the last line of the header
@ -93,9 +101,9 @@ for file in files:
content = file['input'].readlines()
file['input'].close()
info = {'resolution': [0,0,0],
'dimension': [0.0,0.0,0.0],
'origin': [0.0,0.0,0.0],
info = {'resolution': numpy.array([0,0,0]),
'dimension': numpy.array([0.0,0.0,0.0]),
'origin': numpy.array([0.0,0.0,0.0]),
'homogenization': 1,
}
@ -110,17 +118,17 @@ for file in files:
else:
info[headitems[0]] = mappings[headitems[0]](headitems[1])
if info['resolution'] == [0,0,0]:
print 'no resolution info found.'
if info['resolution'].all() == 0:
file['croak'].write('no resolution info found.\n')
continue
if info['dimension'] == [0.0,0.0,0.0]:
print 'no dimension info found.'
file['croak'].write('no dimension info found.\n')
continue
if file['name'] != 'STDIN':
print 'resolution: %s'%(' x '.join(map(str,info['resolution'])))
print 'dimension: %s'%(' x '.join(map(str,info['dimension'])))
print 'origin: %s'%(' : '.join(map(str,info['origin'])))
file['croak'].write('resolution: %s\n'%(' x '.join(map(str,info['resolution']))) + \
'dimension: %s\n'%(' x '.join(map(str,info['dimension']))) + \
'origin: %s\n'%(' : '.join(map(str,info['origin']))) + \
'homogenization: %i\n'%info['homogenization'])
new_header.append("resolution\ta %i\tb %i\tc %i\n"%(
info['resolution'][0],

View File

@ -29,10 +29,13 @@ class extendedOption(Option):
identifiers = {
'resolution': ['a','b','c'],
'dimension': ['x','y','z'],
'origin': ['x','y','z'],
}
mappings = {
'resolution': lambda x: int(x),
'dimension': lambda x: float(x),
'origin': lambda x: float(x),
'homogenization': lambda x: int(x),
}
@ -43,13 +46,14 @@ i.e. within the region close to a grain/phase boundary.
)
parser.add_option('-v', '--vicinity', dest='vicinity', type='int', \
help='voxel distance checked for presence of other microstructure')
help='voxel distance checked for presence of other microstructure [%default]')
parser.add_option('-o', '--offset', dest='offset', type='int', \
help='integer offset for tagged microstructure')
help='integer offset for tagged microstructure [%default]')
parser.add_option('-2', '--twodimensional', dest='twoD', action='store_true', \
help='output geom file with two-dimensional data arrangement')
parser.set_defaults(vicinity = 1)
parser.set_defaults(offset = 0)
parser.set_defaults(twoD = False)
(options, filenames) = parser.parse_args()
@ -58,16 +62,25 @@ parser.set_defaults(twoD = False)
files = []
if filenames == []:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
files.append({'name':'STDIN',
'input':sys.stdin,
'output':sys.stdout,
'croak':sys.stderr,
})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w')})
files.append({'name':name,
'input':open(name),
'output':open(name+'_tmp','w'),
'croak':sys.stdout,
})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
if file['name'] != 'STDIN': print file['name']
if file['name'] != 'STDIN': file['croak'].write(file['name']+'\n')
# get labels by either read the first row, or - if keyword header is present - the last line of the header
@ -83,40 +96,52 @@ for file in files:
content = file['input'].readlines()
file['input'].close()
resolution = [0,0,0]
dimension = [0.0,0.0,0.0]
info = {'resolution': numpy.array([0,0,0]),
'dimension': numpy.array([0.0,0.0,0.0]),
'origin': numpy.array([0.0,0.0,0.0]),
'homogenization': 1,
}
new_header = []
for header in headers:
headitems = header.split()
if headitems[0] == 'resolution': # located resolution entry
for i in xrange(3):
resolution[i] = mappings['resolution'](headitems[headitems.index(identifiers['resolution'][i])+1])
if headitems[0] == 'dimension': # located dimension entry
for i in xrange(3):
dimension[i] = mappings['dimension'](headitems[headitems.index(identifiers['dimension'][i])+1])
headitems = map(str.lower,header.split())
if headitems[0] in mappings.keys():
if headitems[0] in identifiers.keys():
for i in xrange(len(identifiers[headitems[0]])):
info[headitems[0]][i] = \
mappings[headitems[0]](headitems[headitems.index(identifiers[headitems[0]][i])+1])
else:
info[headitems[0]] = mappings[headitems[0]](headitems[1])
if resolution == [0,0,0]:
print 'no resolution info found.'
sys.exit(1)
if dimension == [0.0,0.0,0.0]:
print 'no dimension info found.'
sys.exit(1)
if info['resolution'].all() == 0:
file['croak'].write('no resolution info found.\n')
continue
if info['dimension'].all() == 0:
file['croak'].write('no dimension info found.\n')
continue
if file['name'] != 'STDIN':
print 'resolution: %s'%(' x '.join(map(str,resolution)))
print 'dimension: %s'%(' x '.join(map(str,dimension)))
file['croak'].write('resolution: %s\n'%(' x '.join(map(str,info['resolution']))) + \
'dimension: %s\n'%(' x '.join(map(str,info['dimension']))) + \
'origin: %s\n'%(' : '.join(map(str,info['origin']))) + \
'homogenization: %i\n'%info['homogenization'])
microstructure = numpy.zeros(resolution,'i')
microstructure = numpy.zeros(info['resolution'],'i')
i = 0
for line in content:
for item in map(int,line.split()):
microstructure[i%resolution[0],(i/resolution[0])%resolution[1],i/resolution[0]/resolution[1]] = item
microstructure[i%info['resolution'][0],
(i/info['resolution'][0])%info['resolution'][1],
i/info['resolution'][0] /info['resolution'][1]] = item
i += 1
formatwidth = 1+int(math.floor(math.log10(abs(microstructure.max()+options.offset))))
if options.offset == 0:
options.offset = microstructure.max()
file['croak'].write('offset: %i\n'%options.offset)
formatwidth = int(math.floor(math.log10(microstructure.max())))
for x in xrange(resolution[0]):
for y in xrange(resolution[1]):
for z in xrange(resolution[2]):
for x in xrange(info['resolution'][0]):
for y in xrange(info['resolution'][1]):
for z in xrange(info['resolution'][2]):
me = microstructure[x,y,z]
breaker = False
@ -125,7 +150,7 @@ for file in files:
for dy in xrange(-options.vicinity,options.vicinity+1):
for dz in xrange(-options.vicinity,options.vicinity+1):
they = microstructure[(x+dx)%resolution[0],(y+dy)%resolution[1],(z+dz)%resolution[2]]
they = microstructure[(x+dx)%info['resolution'][0],(y+dy)%info['resolution'][1],(z+dz)%info['resolution'][2]]
if they != me and they != me+options.offset: # located alien microstructure in vicinity
microstructure[x,y,z] += options.offset # tag myself as close to aliens!
breaker = True
@ -142,9 +167,9 @@ for file in files:
# ------------------------------------- regenerate texture information ----------------------------------
for z in xrange(resolution[2]):
for y in xrange(resolution[1]):
output += {True:' ',False:'\n'}[options.twoD].join(map(lambda x: ('%%%ii'%formatwidth)%x, microstructure[:,y,z])) + '\n'
for z in xrange(info['resolution'][2]):
for y in xrange(info['resolution'][1]):
output += {True:' ',False:'\n'}[options.twoD].join(map(lambda x: str(x).rjust(formatwidth), microstructure[:,y,z])) + '\n'
output += '\n'

82
processing/pre/randomSeeding.py Executable file
View File

@ -0,0 +1,82 @@
#!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*-
import os,sys,string,re,math,numpy,random
from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
# -----------------------------
class extendedOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# ----------------------- MAIN -------------------------------
identifiers = {
'resolution': ['a','b','c'],
'dimension': ['x','y','z'],
}
mappings = {
'resolution': lambda x: int(x),
'dimension': lambda x: float(x),
}
parser = OptionParser(option_class=extendedOption, usage='%prog [options]', description = """
Distribute given number of points randomly within the three-dimensional cube [0,0,0]--[1,1,1].
Reports positions with random crystal orientations in seeds file format to STDOUT.
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-N', dest='N', type='int', \
help='number of seed points to distribute [%default]')
parser.add_option('-r','--resolution', dest='res', type='int', nargs=3, \
help='Min Fourier points in x, y, z %default')
parser.add_option('-s', '--rnd', dest='randomSeed', type='int', \
help='seed of random number generator [%default]')
parser.set_defaults(randomSeed = 0)
parser.set_defaults(res = [16,16,16])
parser.set_defaults(N = 20)
(options, extras) = parser.parse_args()
Npoints = options.res[0]*options.res[1]*options.res[2]
if options.N > Npoints:
sys.stderr.write('Warning: more seeds than grid points at minimum resolution.\n')
options.N = Npoints
seeds = numpy.zeros((3,options.N),float)
numpy.random.seed(options.randomSeed)
grainEuler = numpy.random.rand(3,options.N)
grainEuler[0,:] *= 360.0
grainEuler[1,:] = numpy.arccos(2*grainEuler[1,:]-1)*180.0/math.pi
grainEuler[2,:] *= 360.0
seedpoint = numpy.random.permutation(Npoints)[:options.N]
seeds[0,:] = (numpy.mod(seedpoint ,options.res[0])+numpy.random.random())/options.res[0]
seeds[1,:] = (numpy.mod(seedpoint// options.res[0] ,options.res[1])+numpy.random.random())/options.res[1]
seeds[2,:] = (numpy.mod(seedpoint//(options.res[1]*options.res[0]),options.res[2])+numpy.random.random())/options.res[2]
print "4\theader"
print "resolution\ta %i\tb %i\tc %i"%(options.res[0],options.res[1],options.res[2],)
print "grains\t%i"%options.N
print "randomSeed\t%f"%(options.randomSeed)
print "x\ty\tz\tphi1\tPhi\tphi2"
numpy.savetxt(sys.stdout,numpy.transpose(numpy.concatenate((seeds,grainEuler),axis = 0)),fmt='%10.6f',delimiter='\t')

View File

@ -1,170 +0,0 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os,sys,math,string,numpy, damask
from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
# -----------------------------
class extendedOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# --------------------------------------------------------------------
# MAIN
# --------------------------------------------------------------------
parser = OptionParser(option_class=extendedOption, usage='%prog options [file[s]]', description = """
generates geom file and material_config file using seeds file
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-d', '--dimension', dest='dimension', type='float', nargs = 3, \
help='x,y,z dimension of specimen')
parser.add_option('-r', '--resolution', dest='resolution', type='int', nargs = 3, \
help='a,b,c resolution of specimen')
parser.add_option('-o', '--outputName', dest='outputName', type='string', nargs = 1, \
help='Output Name')
parser.set_defaults(resolution = (0,0,0))
parser.set_defaults(dimension = (0.0,0.0,0.0))
parser.set_defaults(outputName = '')
(options,filenames) = parser.parse_args()
# ------------------------------------------ setup file handles ---------------------------------------
files = []
if filenames == []:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
else:
for name in filenames:
if os.path.splitext(name)[1]=='': name = name+'.seeds'
if options.outputName=='': options.outputName = name
if os.path.exists(name):
files.append({'name':name,\
'input':open(name),\
'geom':open(os.path.splitext(options.outputName)[0]+'.geom','w+'),\
'material.config':open(os.path.splitext(options.outputName)[0]+'_material.config','w+')})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
spatialDim = 3
unmapped = 0
if file['name'] != 'STDIN': print file['name']
Favg = numpy.array(([1.0,0.0,0.0],\
[0.0,1.0,0.0],\
[0.0,0.0,1.0]),'d')
for lineCount, line in enumerate(file['input']):
words = line.split()
if('head' in line): headCount=int(words[0])+1
if(lineCount<=headCount):
if('grains'.lower()==words[0]):
N_seeds=int(words[1])
checkGrain=numpy.zeros(N_seeds)
if 'resolution'==words[0] :
if options.resolution==(0,0,0):
resolution=[int(words[2]),int(words[4]),int(words[6])]
else:
resolution = [options.resolution[0],options.resolution[1],options.resolution[2]]
if lineCount==headCount: # all header info there, allocating arrays
if resolution[2]==1: spatialDim=2
validDim = numpy.zeros(3)
dimension = numpy.zeros(3)
for i in xrange(3):
if(options.dimension[i]>0): validDim[i]= 1
for i in xrange(3):
if(any(validDim) and options.dimension[i]==0):
dimension[i] = max(numpy.array(options.dimension,dtype='float')/resolution) *resolution[i]
print 'rescaling invalid dimension '+str(i+1)
if(any(validDim)==0):
print 'No valid dimension specified, rescaling all dimensions'
for i in xrange(spatialDim): dimension[i]=1.0/max(resolution)*resolution[i]
if(all(validDim)): dimension= [options.dimension[0],options.dimension[1],options.dimension[2]]
coords = numpy.zeros((spatialDim,N_seeds),'d')
eulers = numpy.zeros((N_seeds,3),'d')
else:
Npoints = resolution[0]*resolution[1]*resolution[2]
coords[0:spatialDim,lineCount-headCount] = numpy.array(words[0:spatialDim],'d')
eulers[lineCount-headCount,0:3] = words[3:6]
undeformed = numpy.zeros((spatialDim,Npoints),'d').reshape(spatialDim,Npoints)
for i in xrange(spatialDim):
for j in xrange(N_seeds):
if(coords[i][j]>=1.0 or coords[i][j]<0.0):
print 'WARNING: Seed Coordinate '+ str(coords[i][j]) +' located outside Grid '
digits = 1+int(math.log10(int(N_seeds)))
file['geom'].write('3 header' +'\n')
file['geom'].write('resolution a '+ str(resolution[0])+ ' b '+str(resolution[1])+ ' c '+str( resolution[2])+'\n')
file['geom'].write('dimension x '+ str(dimension[0]) + ' y '+ str(dimension[1])+ ' z '+ str( dimension[2])+'\n')
file['geom'].write('homogenization 1'+'\n')
file['material.config'].write('<microstructure>'+'\n')
for i in xrange(N_seeds):
file['material.config'].write('[Grain' +str( i+1).zfill(digits)+']'+'\n')
file['material.config'].write('crystallite 1'+'\n')
file['material.config'].write('(constituent) phase 1 texture '+ str(i+1).zfill(digits)+ ' fraction 1.0'+'\n')
file['material.config'].write('\n'+'<texture>'+'\n')
for i in xrange(N_seeds):
file['material.config'].write('[Grain'+ str(i+1).zfill(digits)+ ']'+'\n')
file['material.config'].write('(gauss) phi1 '+ str(eulers[i][0])+ ' Phi '+ str(eulers[i][1])+ \
' phi2 '+ str(eulers[i][2])+ ' scatter 0.0 fraction 1.0'+'\n')
shift = dimension[0:spatialDim]/numpy.array( resolution,dtype='float')[0:spatialDim]*0.5 # shift by half of side length to center of element
for i in xrange(Npoints):
undeformed[0,i] = dimension[0]\
* float(i % resolution[0])\
/float( resolution[0])
undeformed[1,i] = dimension[1]\
* float(i// resolution[0] % resolution[1])\
/float( resolution[1])
if spatialDim==3:
undeformed[2,i] = dimension[2]\
* float(i// resolution[0]// resolution[1] % resolution[2])\
/float( resolution[2])
undeformed[0:spatialDim,i] += shift
indices=damask.core.math.math_nearestNeighborSearch(spatialDim,Favg,numpy.array( dimension,dtype='float'),Npoints,N_seeds,undeformed,coords)
for n in xrange(Npoints):
file['geom'].write( str(indices[n]//3**spatialDim+1).zfill(digits)+{True:'\n',False:' '}[(n+1)% resolution[0] == 0])
grainIndex=indices//3**spatialDim+1
for i in xrange(1,N_seeds+1):
if i not in grainIndex: unmapped+=1
if(unmapped == 0): print 'All Grains Mapped'
else: print 'Only '+str(N_seeds-unmapped )+' Grains mapped'
file['geom'].close()
file['material.config'].close()
file['input'].close()

View File

@ -1,154 +0,0 @@
#!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*-
import os,sys,string,re,math,numpy
from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
# -----------------------------
class extendedOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# ----------------------- MAIN -------------------------------
identifiers = {
'resolution': ['a','b','c'],
'dimension': ['x','y','z'],
}
mappings = {
'resolution': lambda x: int(x),
'dimension': lambda x: float(x),
}
parser = OptionParser(option_class=extendedOption, usage='%prog options [file[s]]', description = """
Multiplies a spectral geometry description independently in x, y, and z direction at fixed dimension.
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-f', '--factor', dest='factor', type='int', nargs = 3, \
help='multiplication factors of a,b,c resolution')
parser.add_option('-2', '--twodimensional', dest='twoD', action='store_true', \
help='output geom file with two-dimensional data arrangement')
parser.add_option('-k', '--keep', dest='keepDimension', action='store_true', \
help='keep dimension as before')
parser.set_defaults(factor = [1,1,1])
parser.set_defaults(twoD = False)
parser.set_defaults(keepDimension = False)
(options, filenames) = parser.parse_args()
prefix = 'mult%ix%ix%i'%(options.factor[0],options.factor[1],options.factor[2])
# ------------------------------------------ setup file handles ---------------------------------------
files = []
if filenames == []:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
else:
for name in filenames:
if os.path.exists(name):
files.append({'name':name, 'input':open(name), 'output':open(prefix+'_'+name,'w')})
# ------------------------------------------ loop over input files ---------------------------------------
for file in files:
if file['name'] != 'STDIN': print file['name']
# get labels by either read the first row, or - if keyword header is present - the last line of the header
firstline = file['input'].readline()
m = re.search('(\d+)\s*head', firstline.lower())
if m:
headerlines = int(m.group(1))
headers = [firstline]+[file['input'].readline() for i in range(headerlines)]
else:
headerlines = 1
headers = firstline
content = file['input'].readlines()
file['input'].close()
resolution = [0,0,0]
dimension = [0.0,0.0,0.0]
resolution_blown = [0,0,0]
dimension_blown = [0.0,0.0,0.0]
new_header = []
for header in headers:
headitems = header.split()
if headitems[0] == 'resolution': # located resolution entry
for i in xrange(3):
resolution[i] = mappings['resolution'](headitems[headitems.index(identifiers['resolution'][i])+1])
resolution_blown[i] = resolution[i]*options.factor[i]
header = "resolution\ta %i\tb %i\tc %i\n"%(resolution_blown[0],resolution_blown[1],resolution_blown[2])
if headitems[0] == 'dimension': # located dimension entry
for i in xrange(3):
dimension[i] = mappings['dimension'](headitems[headitems.index(identifiers['dimension'][i])+1])
if options.keepDimension: dimension_blown[i] = dimension[i]
else: dimension_blown[i] = dimension[i]*options.factor[i]
header = "dimension\tx %f\ty %f\tz %f\n"%(dimension_blown[0],dimension_blown[1],dimension_blown[2])
new_header.append(header)
if resolution == [0,0,0]:
print 'no resolution info found.'
continue
if dimension == [0.0,0.0,0.0]:
print 'no dimension info found.'
continue
if file['name'] != 'STDIN':
print 'resolution: %s'%(' x '.join(map(str,resolution_blown)))
print 'dimension: %s'%(' x '.join(map(str,dimension_blown)))
microstructure = numpy.zeros(resolution,'i')
i = 0
for line in content:
for item in map(int,line.split()):
microstructure[i%resolution[0],(i/resolution[0])%resolution[1],i/resolution[0]/resolution[1]] = item
i += 1
formatwidth = int(math.floor(math.log10(microstructure.max())))
# ------------------------------------------ assemble header ---------------------------------------
output = ''.join(new_header)
# ------------------------------------- regenerate texture information ----------------------------------
for z in xrange(resolution[2]):
for c in xrange(options.factor[2]):
for y in xrange(resolution[1]):
for b in xrange(options.factor[1]):
for x in xrange(resolution[0]):
for a in xrange(options.factor[0]):
output += ('%%%ii'%formatwidth)%microstructure[x,y,z] + {True:' ',False:'\n'}[options.twoD]
output += {True:'\n',False:''}[options.twoD]
# ------------------------------------------ output result ---------------------------------------
file['output'].write(output)
file['input'].close()
if file['name'] != 'STDIN':
file['output'].close()

View File

@ -1,88 +0,0 @@
#!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*-
import os,sys,string,re,math,numpy,random
from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
# -----------------------------
class extendedOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# ----------------------- MAIN -------------------------------
identifiers = {
'resolution': ['a','b','c'],
'dimension': ['x','y','z'],
}
mappings = {
'resolution': lambda x: int(x),
'dimension': lambda x: float(x),
}
parser = OptionParser(option_class=extendedOption, usage='%prog options [file[s]]', description = """
Offset microstructure index for points which see a microstructure different from themselves within a given (cubic) vicinity,
i.e. within the region close to a grain/phase boundary.
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-f', '--file', dest='filename', type="string", \
help='output seed file name [%default]')
parser.add_option('-s', '--seed', dest='randomSeed', type='int', \
help='seed of random number generator [%default]')
parser.add_option('-n', '--ngrains', dest='N_Seeds', type='int', \
help='seed of random number generator[%default]')
parser.add_option('-r','--res', dest='res', type='int', nargs=3, \
help='Min Fourier points in x, y, z [%default]')
parser.set_defaults(filename = 'seeds')
parser.set_defaults(randomSeed = 0)
parser.set_defaults(res=[16,16,16])
parser.set_defaults(N_Seeds=50)
(options, filenames) = parser.parse_args()
if options.N_Seeds > options.res[0]*options.res[1]*options.res[2]:
print 'Warning: Number of grains exceeds min resolution'
options.N_Seeds = options.res[0]*options.res[1]*options.res[2]
seeds = numpy.zeros((3,options.N_Seeds),float)
numpy.random.seed(options.randomSeed)
grainEuler=numpy.random.rand(3,options.N_Seeds)
grainEuler[0,:] = 360*grainEuler[0,:]
grainEuler[1,:] = numpy.arccos(2*grainEuler[1,:]-1)*180/math.pi
grainEuler[2,:] = 360*grainEuler[2,:]
seedpoint = numpy.random.permutation(options.res[0]*options.res[1]*options.res[2])[:options.N_Seeds]
seeds[0,:]=(numpy.mod(seedpoint ,options.res[0])+numpy.random.random())/options.res[0]
seeds[1,:]=(numpy.mod(seedpoint// options.res[0] ,options.res[1])+numpy.random.random())/options.res[1]
seeds[2,:]=(numpy.mod(seedpoint//(options.res[1]*options.res[0]),options.res[2])+numpy.random.random())/options.res[2]
f = open(options.filename+'.seeds', 'w')
f.write("{0:1d} {1:6s}\n".format(4,'header'))
f.write("{0:s} {1:8d} {2:s} {3:8d} {4:s} {5:8d}\n".format('resolution a',options.res[0],'b',options.res[1],'c',options.res[2]))
f.write("{0:s} {1:8d}\n".format('grains',options.N_Seeds))
f.write("{0:s} {1:8d}\n".format('random seed',options.randomSeed))
f.write("x y z phi1 Phi phi2\n")
f.close()
f=file(options.filename+'.seeds','a')
numpy.savetxt(f,numpy.transpose(numpy.concatenate((seeds,grainEuler),axis=0)),fmt='%10.6f',delimiter=' ')
f.close()

View File

@ -82,17 +82,17 @@ bin_link = { \
'mentat_spectralBox.py',
'OIMang_hex2cub.py',
'patchFromReconstructedBoundaries.py',
'spectral_geomCanvas.py',
'spectral_geomCheck.py',
'spectral_geomFromAng.py',
'spectral_geomFromMinimalSurface.py',
'spectral_geomFromVoronoiTessellation.py',
'spectral_geomMultiply.py',
'spectral_geomPack.py',
'spectral_geomTranslate.py',
'spectral_geomUnpack.py',
'spectral_geomVicinityOffset.py',
'spectral_randomSeeding.py',
'geom_canvas.py',
'geom_check.py',
'geom_fromVoronoiTessellation.py',
'geom_rescale.py',
'geom_pack.py',
'geom_unpack.py',
'geom_translate.py',
'geom_vicinityOffset.py',
'randomSeeding.py',
],
'post' : [
'3Dvisualize.py',