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

processing/pre/geom_canvas.py

@@ -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],
+  info = {'resolution': numpy.array(options.resolution),
-          'dimension':  [0.0,0.0,0.0],
+          'dimension':  numpy.array([0.0,0.0,0.0]),
-          'origin':     [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]:
+  if options.resolution == [0,0,0]:
-    print 'no resolution info found.'
+    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':
+  file['croak'].write('resolution:     %s\n'%(' x '.join(map(str,info['resolution']))) + \
-    print 'resolution: %s'%(' x '.join(map(str,info['resolution'])))
+                      'dimension:      %s\n'%(' x '.join(map(str,info['dimension']))) + \
-    print 'dimension:  %s'%(' x '.join(map(str,info['dimension'])))
+                      'origin:         %s\n'%(' : '.join(map(str,info['origin']))) + \
-    print 'origin:     %s'%(' x '.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')

processing/pre/geom_fromVoronoiTessellation.py

@@ -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])
+

processing/pre/geom_rescale.py

@@ -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()
+    

processing/pre/geom_translate.py

@@ -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],
+  info = {'resolution': numpy.array([0,0,0]),
-          'dimension':  [0.0,0.0,0.0],
+          'dimension':  numpy.array([0.0,0.0,0.0]),
-          'origin':     [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]:
+  if info['resolution'].all() == 0:
-    print 'no resolution info found.'
+    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':
+  file['croak'].write('resolution:     %s\n'%(' x '.join(map(str,info['resolution']))) + \
-    print 'resolution: %s'%(' x '.join(map(str,info['resolution'])))
+                      'dimension:      %s\n'%(' x '.join(map(str,info['dimension']))) + \
-    print 'dimension:  %s'%(' x '.join(map(str,info['dimension'])))
+                      'origin:         %s\n'%(' : '.join(map(str,info['origin']))) + \
-    print 'origin:     %s'%(' : '.join(map(str,info['origin'])))
+                      'homogenization: %i\n'%info['homogenization'])
 
   new_header.append("resolution\ta %i\tb %i\tc %i\n"%( 
     info['resolution'][0],

processing/pre/geom_vicinityOffset.py

@@ -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]
+  info = {'resolution': numpy.array([0,0,0]),
-  dimension = [0.0,0.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()
+    headitems = map(str.lower,header.split())
-    if headitems[0] == 'resolution':         # located resolution entry
+    if headitems[0] in mappings.keys():
-      for i in xrange(3):
+      if headitems[0] in identifiers.keys():
-        resolution[i] = mappings['resolution'](headitems[headitems.index(identifiers['resolution'][i])+1])
+        for i in xrange(len(identifiers[headitems[0]])):
-    if headitems[0] == 'dimension':          # located dimension entry
+          info[headitems[0]][i] = \
-      for i in xrange(3):
+            mappings[headitems[0]](headitems[headitems.index(identifiers[headitems[0]][i])+1])
-        dimension[i] = mappings['dimension'](headitems[headitems.index(identifiers['dimension'][i])+1])
+      else:
+        info[headitems[0]] = mappings[headitems[0]](headitems[1])
 
-  if resolution == [0,0,0]:
+  if info['resolution'].all() == 0:
-    print 'no resolution info found.'
+    file['croak'].write('no resolution info found.\n')
-    sys.exit(1)
+    continue
-  if dimension == [0.0,0.0,0.0]:
+  if info['dimension'].all() == 0:
-    print 'no dimension info found.'
+    file['croak'].write('no dimension info found.\n')
-    sys.exit(1)
+    continue
 
-  if file['name'] != 'STDIN':
+  file['croak'].write('resolution:     %s\n'%(' x '.join(map(str,info['resolution']))) + \
-    print 'resolution: %s'%(' x '.join(map(str,resolution)))
+                      'dimension:      %s\n'%(' x '.join(map(str,info['dimension']))) + \
-    print 'dimension:  %s'%(' x '.join(map(str,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(info['resolution'][0]):
-  
+    for y in xrange(info['resolution'][1]):
-  for x in xrange(resolution[0]):
+      for z in xrange(info['resolution'][2]):
-    for y in xrange(resolution[1]):
-      for z in xrange(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 z in xrange(info['resolution'][2]):
-    for y in xrange(resolution[1]):
+    for y in xrange(info['resolution'][1]):
-      output += {True:' ',False:'\n'}[options.twoD].join(map(lambda x: ('%%%ii'%formatwidth)%x, microstructure[:,y,z])) + '\n'
+      output += {True:' ',False:'\n'}[options.twoD].join(map(lambda x: str(x).rjust(formatwidth), microstructure[:,y,z])) + '\n'
     
     output += '\n'
     

processing/pre/randomSeeding.py

@@ -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')

processing/pre/spectral_geomFromVoronoiTessellation.py

@@ -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()
-      

processing/pre/spectral_geomMultiply.py

@@ -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()
-    

processing/pre/spectral_randomSeeding.py

@@ -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()

processing/setup/setup_processing.py

@@ -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',
+                'geom_canvas.py',
-                'spectral_geomMultiply.py',
+                'geom_check.py',
-                'spectral_geomPack.py',
+                'geom_fromVoronoiTessellation.py',
-                'spectral_geomTranslate.py',
+                'geom_rescale.py',
-                'spectral_geomUnpack.py',
+                'geom_pack.py',
-                'spectral_geomVicinityOffset.py',
+                'geom_unpack.py',
-                'spectral_randomSeeding.py',
+                'geom_translate.py',
+                'geom_vicinityOffset.py',
+                'randomSeeding.py',
                 ],
         'post' : [
                 '3Dvisualize.py',