simplified

- always use quaternion as input for orientation
- addAPS34IDEstrainCoords uses table functionality
- rotateData can figure out whether input is vector or tensor

processing/post/addAPS34IDEstrainCoords.py

@@ -35,21 +35,27 @@ datainfo = {'len':3,
 
 datainfo['label']  += options.frame
 
-# --- loop over input files -------------------------------------------------------------------------
+# --- loop over input files ------------------------------------------------------------------------
-if filenames == []:
+
-  filenames = ['STDIN']
+if filenames == []: filenames = [None]
 
 for name in filenames:
-  if name == 'STDIN':
+  try:    table = damask.ASCIItable(name = name,
-    file = {'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout, 'croak':sys.stderr}
+                                    buffered = False)
-    file['croak'].write('\033[1m'+scriptName+'\033[0m\n')
+  except: continue
-  else:
+  damask.util.report(scriptName,name)
-    if not os.path.exists(name): continue
+
-    file = {'name':name, 'input':open(name), 'output':open(name+'_tmp','w'), 'croak':sys.stderr}
+# ------------------------------------------ read header ------------------------------------------
-    file['croak'].write('\033[1m'+scriptName+'\033[0m: '+file['name']+'\n')
+
+  table.head_read()
+
+  if not table.label_dimension(options.quaternion) == 4:
+    damask.util.croak('input {} does not have dimension 4.'.format(options.quaternion))
+    table.close(dismiss = True)                                                                     # close ASCIItable and remove empty file
+    continue
+
+
 
-  table = damask.ASCIItable(file['input'],file['output'],buffered=False)                            # make unbuffered ASCII_table
-  table.head_read()                                                                                 # read ASCII header info
   table.info_append(scriptID + '\t' + ' '.join(sys.argv[1:]))
 
 # --------------- figure out columns to process  ---------------------------------------------------

processing/post/addGrainID.py

@@ -31,32 +31,6 @@ parser.add_option('-s',
                   dest = 'symmetry',
                   type = 'string', metavar = 'string',
                   help = 'crystal symmetry [%default]')
-parser.add_option('-e',
-                  '--eulers',
-                  dest = 'eulers',
-                  type = 'string', metavar = 'string',
-                  help = 'label of Euler angles')
-parser.add_option('--degrees',
-                  dest = 'degrees',
-                  action = 'store_true',
-                  help = 'Euler angles are given in degrees [%default]')
-parser.add_option('-m',
-                  '--matrix',
-                  dest = 'matrix',
-                  type = 'string', metavar = 'string',
-                  help = 'label of orientation matrix')
-parser.add_option('-a',
-                  dest = 'a',
-                  type = 'string', metavar = 'string',
-                  help = 'label of crystal frame a vector')
-parser.add_option('-b',
-                  dest = 'b',
-                  type = 'string', metavar = 'string',
-                  help = 'label of crystal frame b vector')
-parser.add_option('-c',
-                  dest = 'c',
-                  type = 'string', metavar = 'string',
-                  help = 'label of crystal frame c vector')
 parser.add_option('-q',
                   '--quaternion',
                   dest = 'quaternion',
@@ -69,9 +43,9 @@ parser.add_option('-p',
                   help = 'label of coordinates [%default]')
 
 parser.set_defaults(disorientation = 5,
+                    quaternion = 'orientation',
                     symmetry = 'cubic',
                     pos      = 'pos',
-                    degrees  = False,
                    )
 
 (options, filenames) = parser.parse_args()
@@ -79,22 +53,6 @@ parser.set_defaults(disorientation = 5,
 if options.radius is None:
   parser.error('no radius specified.')
 
-input = [options.eulers     is not None,
-         options.a          is not None and \
-         options.b          is not None and \
-         options.c          is not None,
-         options.matrix     is not None,
-         options.quaternion is not None,
-        ]
-
-if np.sum(input) != 1: parser.error('needs exactly one input format.')
-
-(label,dim,inputtype) = [(options.eulers,3,'eulers'),
-                         ([options.a,options.b,options.c],[3,3,3],'frame'),
-                         (options.matrix,9,'matrix'),
-                         (options.quaternion,4,'quaternion'),
-                        ][np.where(input)[0][0]]                                                    # select input label that was requested
-toRadians = np.pi/180.0 if options.degrees else 1.0                                                 # rescale degrees to radians
 cos_disorientation = np.cos(np.radians(options.disorientation/2.))                                  # cos of half the disorientation angle
 
 # --- loop over input files -------------------------------------------------------------------------
@@ -118,8 +76,8 @@ for name in filenames:
   
   if not 3 >= table.label_dimension(options.pos) >= 1:
     errors.append('coordinates "{}" need to have one, two, or three dimensions.'.format(options.pos))
-  if not np.all(table.label_dimension(label) == dim):
+  if not np.all(table.label_dimension(options.quaternion) == 4):
-    errors.append('input "{}" does not have dimension {}.'.format(label,dim))
+    errors.append('input "{}" does not have dimension 4.'.format(options.quaternion))
   else:  column = table.label_index(label)
 
   if remarks != []: damask.util.croak(remarks)
@@ -131,9 +89,7 @@ for name in filenames:
 # ------------------------------------------ assemble header ---------------------------------------
 
   table.info_append(scriptID + '\t' + ' '.join(sys.argv[1:]))
-  table.labels_append('grainID_{}@{:g}'.format('+'.join(label) 
+  table.labels_append('grainID_{}@{:g}'.format('+'.join(options.quaternion),
-                                               if isinstance(label, (list,tuple))
-                                               else label,
                                                options.disorientation))                        # report orientation source and disorientation
   table.head_write()
 
@@ -141,16 +97,14 @@ for name in filenames:
 
 # ------------------------------------------ build KD tree -----------------------------------------
 
+  table.data_readArray(options.pos)                                                                 # read position vectors
+  grainID = -np.ones(len(table.data),dtype=int)
+
 # --- start background messaging
 
   bg = damask.util.backgroundMessage()
   bg.start()
 
-  bg.set_message('reading positions...')
-
-  table.data_readArray(options.pos)                                                                 # read position vectors
-  grainID = -np.ones(len(table.data),dtype=int)
-
   start = tick = time.clock()
   bg.set_message('building KD tree...')
   kdtree = spatial.KDTree(copy.deepcopy(table.data))
@@ -175,18 +129,6 @@ for name in filenames:
       bg.set_message('(%02i:%02i:%02i) processing point %i of %i (grain count %i)...'\
             %(time_delta//3600,time_delta%3600//60,time_delta%60,p,len(grainID),np.count_nonzero(memberCounts)))
 
-    if inputtype == 'eulers':
-      o = damask.Orientation(Eulers   = np.array(map(float,table.data[column:column+3]))*toRadians,
-                             symmetry = options.symmetry).reduced()
-    elif inputtype == 'matrix':
-      o = damask.Orientation(matrix   = np.array(map(float,table.data[column:column+9])).reshape(3,3).transpose(),
-                             symmetry = options.symmetry).reduced()
-    elif inputtype == 'frame':
-      o = damask.Orientation(matrix = np.array(map(float,table.data[column[0]:column[0]+3] + \
-                                                         table.data[column[1]:column[1]+3] + \
-                                                         table.data[column[2]:column[2]+3])).reshape(3,3),
-                             symmetry = options.symmetry).reduced()
-    elif inputtype == 'quaternion':
     o = damask.Orientation(quaternion = np.array(map(float,table.data[column:column+4])),
                            symmetry   = options.symmetry).reduced()
 

processing/post/addIPFcolor.py

@@ -26,58 +26,18 @@ parser.add_option('-s', '--symmetry',
                   dest = 'symmetry',
                   type = 'choice', choices = damask.Symmetry.lattices[1:], metavar='string',
                   help = 'crystal symmetry [%default] {{{}}} '.format(', '.join(damask.Symmetry.lattices[1:])))
-parser.add_option('-e', '--eulers',
-                  dest = 'eulers',
-                  type = 'string', metavar = 'string',
-                  help = 'Euler angles label')
-parser.add_option('-d', '--degrees',
-                  dest = 'degrees',
-                  action = 'store_true',
-                  help = 'Euler angles are given in degrees [%default]')
-parser.add_option('-m', '--matrix',
-                  dest = 'matrix',
-                  type = 'string', metavar = 'string',
-                  help = 'orientation matrix label')
-parser.add_option('-a',
-                  dest = 'a',
-                  type = 'string', metavar = 'string',
-                  help = 'crystal frame a vector label')
-parser.add_option('-b',
-                  dest = 'b',
-                  type = 'string', metavar = 'string',
-                  help = 'crystal frame b vector label')
-parser.add_option('-c',
-                  dest = 'c',
-                  type = 'string', metavar = 'string',
-                  help = 'crystal frame c vector label')
 parser.add_option('-q', '--quaternion',
                   dest = 'quaternion',
                   type = 'string', metavar = 'string',
                   help = 'quaternion label')
 
 parser.set_defaults(pole = (0.0,0.0,1.0),
+                    quaternion = 'orientation',
                     symmetry = damask.Symmetry.lattices[-1],
-                    degrees = False,
                    )
 
 (options, filenames) = parser.parse_args()
 
-input = [options.eulers     is not None,
-         options.a          is not None and \
-         options.b          is not None and \
-         options.c          is not None,
-         options.matrix     is not None,
-         options.quaternion is not None,
-        ]
-
-if np.sum(input) != 1: parser.error('needs exactly one input format.')
-
-(label,dim,inputtype) = [(options.eulers,3,'eulers'),
-                         ([options.a,options.b,options.c],[3,3,3],'frame'),
-                         (options.matrix,9,'matrix'),
-                         (options.quaternion,4,'quaternion'),
-                        ][np.where(input)[0][0]]                                                    # select input label that was requested
-toRadians = math.pi/180.0 if options.degrees else 1.0                                               # rescale degrees to radians
 pole = np.array(options.pole)
 pole /= np.linalg.norm(pole)
 
@@ -98,12 +58,12 @@ for name in filenames:
 
 # ------------------------------------------ sanity checks ----------------------------------------
 
-  if not np.all(table.label_dimension(label) == dim):
+  if not table.label_dimension(options.quaternion) == 4:
-    damask.util.croak('input {} does not have dimension {}.'.format(label,dim))
+    damask.util.croak('input {} does not have dimension 4.'.format(options.quaternion))
     table.close(dismiss = True)                                                                     # close ASCIItable and remove empty file
     continue
 
-  column = table.label_index(label)
+  column = table.label_index(options.quaternion)
 
 # ------------------------------------------ assemble header ---------------------------------------
 
@@ -115,18 +75,6 @@ for name in filenames:
 
   outputAlive = True
   while outputAlive and table.data_read():                                                          # read next data line of ASCII table
-    if inputtype == 'eulers':
-      o = damask.Orientation(Eulers   = np.array(list(map(float,table.data[column:column+3])))*toRadians,
-                             symmetry = options.symmetry).reduced()
-    elif inputtype == 'matrix':
-      o = damask.Orientation(matrix   = np.array(list(map(float,table.data[column:column+9]))).reshape(3,3).transpose(),
-                             symmetry = options.symmetry).reduced()
-    elif inputtype == 'frame':
-      o = damask.Orientation(matrix = np.array(list(map(float,table.data[column[0]:column[0]+3] + \
-                                                         table.data[column[1]:column[1]+3] + \
-                                                         table.data[column[2]:column[2]+3]))).reshape(3,3),
-                             symmetry = options.symmetry).reduced()
-    elif inputtype == 'quaternion':
     o = damask.Orientation(quaternion = np.array(list(map(float,table.data[column:column+4]))),
                            symmetry   = options.symmetry).reduced()
 

processing/post/addPole.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python2.7
+#!/usr/bin/env python3
 # -*- coding: UTF-8 no BOM -*-
 
 import os,sys,math
@@ -26,58 +26,18 @@ parser.add_option('--polar',
                   dest = 'polar',
                   action = 'store_true',
                   help = 'output polar coordinates r,phi [%default]')
-parser.add_option('-e', '--eulers',
-                  dest = 'eulers',
-                  type = 'string', metavar = 'string',
-                  help = 'Euler angles label')
-parser.add_option('-d', '--degrees',
-                  dest = 'degrees',
-                  action = 'store_true',
-                  help = 'Euler angles are given in degrees [%default]')
-parser.add_option('-m', '--matrix',
-                  dest = 'matrix',
-                  type = 'string', metavar = 'string',
-                  help = 'orientation matrix label')
-parser.add_option('-a',
-                  dest = 'a',
-                  type = 'string', metavar = 'string',
-                  help = 'crystal frame a vector label')
-parser.add_option('-b',
-                  dest = 'b',
-                  type = 'string', metavar = 'string',
-                  help = 'crystal frame b vector label')
-parser.add_option('-c',
-                  dest = 'c',
-                  type = 'string', metavar = 'string',
-                  help = 'crystal frame c vector label')
 parser.add_option('-q', '--quaternion',
                   dest = 'quaternion',
                   type = 'string', metavar = 'string',
                   help = 'quaternion label')
 
 parser.set_defaults(pole = (1.0,0.0,0.0),
-                    degrees = False,
+                    quaternion = 'orientation',
                     polar   = False,
                    )
 
 (options, filenames) = parser.parse_args()
 
-input = [options.eulers     is not None,
-         options.a          is not None and \
-         options.b          is not None and \
-         options.c          is not None,
-         options.matrix     is not None,
-         options.quaternion is not None,
-        ]
-
-if np.sum(input) != 1: parser.error('needs exactly one input format.')
-
-(label,dim,inputtype) = [(options.eulers,3,'eulers'),
-                         ([options.a,options.b,options.c],[3,3,3],'frame'),
-                         (options.matrix,9,'matrix'),
-                         (options.quaternion,4,'quaternion'),
-                        ][np.where(input)[0][0]]                                                    # select input label that was requested
-toRadians = math.pi/180.0 if options.degrees else 1.0                                               # rescale degrees to radians
 pole = np.array(options.pole)
 pole /= np.linalg.norm(pole)
 
@@ -98,18 +58,13 @@ for name in filenames:
 
 # ------------------------------------------ sanity checks ----------------------------------------
 
-  errors  = []
+  if not table.label_dimension(options.quaternion) == 4:
-  remarks = []
+    damask.util.croak('input {} does not have dimension 4.'.format(options.quaternion))
-  
+    table.close(dismiss = True)                                                                     # close ASCIItable and remove empty file
-  if not np.all(table.label_dimension(label) == dim):  errors.append('input {} does not have dimension {}.'.format(label,dim))
-  else:  column = table.label_index(label)
-
-  if remarks != []: damask.util.croak(remarks)
-  if errors  != []:
-    damask.util.croak(errors)
-    table.close(dismiss = True)
     continue
 
+  column = table.label_index(options.quaternion)
+
 # ------------------------------------------ assemble header ---------------------------------------
 
   table.info_append(scriptID + '\t' + ' '.join(sys.argv[1:]))
@@ -119,15 +74,6 @@ for name in filenames:
 # ------------------------------------------ process data ------------------------------------------
   outputAlive = True
   while outputAlive and table.data_read():                                                          # read next data line of ASCII table
-    if inputtype == 'eulers':
-      o = damask.Orientation(Eulers = np.array(list(map(float,table.data[column:column+3])))*toRadians)
-    elif inputtype == 'matrix':
-      o = damask.Orientation(matrix = np.array(list(map(float,table.data[column:column+9]))).reshape(3,3).transpose())
-    elif inputtype == 'frame':
-      o = damask.Orientation(matrix = np.array(list(map(float,table.data[column[0]:column[0]+3] + \
-                                                              table.data[column[1]:column[1]+3] + \
-                                                              table.data[column[2]:column[2]+3]))).reshape(3,3))
-    elif inputtype == 'quaternion':
     o = damask.Orientation(quaternion = np.array(list(map(float,table.data[column:column+4]))))
 
     rotatedPole = o.quaternion*pole                                                                 # rotate pole according to crystal orientation

processing/post/rotateData.py

@@ -18,19 +18,15 @@ Rotate vector and/or tensor column data by given angle around given axis.
 
 """, version = scriptID)
 
-parser.add_option('-v','--vector',
+parser.add_option('-d', '--data',
-                  dest = 'vector',
+                  dest = 'data',
                   action = 'extend', metavar = '<string LIST>',
-                  help = 'column heading of vector(s) to rotate')
+                  help = 'vector/tensor value(s) label(s)')
-parser.add_option('-t','--tensor',
-                  dest = 'tensor',
-                  action = 'extend', metavar = '<string LIST>',
-                  help = 'column heading of tensor(s) to rotate')
 parser.add_option('-r', '--rotation',
                   dest = 'rotation',
                   type = 'float', nargs = 4, metavar = ' '.join(['float']*4),
                   help = 'angle and axis to rotate data [%default]')
-parser.add_option('-d', '--degrees',
+parser.add_option('--degrees',
                   dest = 'degrees',
                   action = 'store_true',
                   help = 'angles are given in degrees [%default]')
@@ -41,7 +37,7 @@ parser.set_defaults(rotation = (0.,1.,1.,1.),
                     
 (options,filenames) = parser.parse_args()
 
-if options.vector is None and options.tensor is None:
+if options.data is None:
   parser.error('no data column specified.')
 
 toRadians = math.pi/180.0 if options.degrees else 1.0                                               # rescale degrees to radians
@@ -59,27 +55,24 @@ for name in filenames:
   except: continue
   damask.util.report(scriptName,name)
 
-# ------------------------------------------ read header ------------------------------------------
+# --- interpret header ----------------------------------------------------------------------------
 
   table.head_read()
 
-# ------------------------------------------ sanity checks ----------------------------------------
-
-  items = {
-            'tensor': {'dim': 9, 'shape': [3,3], 'labels':options.tensor, 'active':[], 'column': []},
-            'vector': {'dim': 3, 'shape': [3],   'labels':options.vector, 'active':[], 'column': []},
-          }
   errors  = []
   remarks = []
-  column = {}
+  active  = {'vector':[],'tensor':[]}
 
-  for type, data in items.items():
+  for i,dim in enumerate(table.label_dimension(options.data)):
-    for what in data['labels']:
+    label = options.data[i]
-      dim = table.label_dimension(what)
+    if dim == -1:
-      if dim != data['dim']: remarks.append('column {} is not a {}.'.format(what,type))
+      remarks.append('{} "{}" not found...'.format(datatype,me))
-      else:
+    elif dim ==  3:
-        items[type]['active'].append(what)
+      remarks.append('adding vector "{}"...'.format(label))
-        items[type]['column'].append(table.label_index(what))
+      active['vector'].append(label)
+    elif dim ==  9:
+      remarks.append('adding tensor "{}"...'.format(label))
+      active['tensor'].append(label)
 
   if remarks != []: damask.util.croak(remarks)
   if errors  != []:
@@ -95,20 +88,14 @@ for name in filenames:
 # ------------------------------------------ process data ------------------------------------------
   outputAlive = True
   while outputAlive and table.data_read():                                                          # read next data line of ASCII table
-
+    for v in active['vector']:
-    datatype = 'vector'
+      column = table.label_index(v)
-
+      table.data[column:column+3] = q * np.array(list(map(float,table.data[column:column+3])))
-    for column in items[datatype]['column']:                                                        # loop over all requested labels
+    for t in active['tensor']:
-      table.data[column:column+items[datatype]['dim']] = \
+      column = table.label_index(v)
-        q * np.array(list(map(float,table.data[column:column+items[datatype]['dim']])))
+      table.data[column:column+9] = \
-
+        np.dot(R,np.dot(np.array(list(map(float,table.data[column:column+9]]))).\
-    datatype = 'tensor'
+                        reshape((3,3)),R.transpose())).reshape((9))
-
-    for column in items[datatype]['column']:                                                        # loop over all requested labels
-      table.data[column:column+items[datatype]['dim']] = \
-        np.dot(R,np.dot(np.array(list(map(float,table.data[column:column+items[datatype]['dim']]))).\
-                        reshape(items[datatype]['shape']),R.transpose())).reshape(items[datatype]['dim'])
-
     outputAlive = table.data_write()                                                                # output processed line
 
 # ------------------------------------------ output finalization -----------------------------------