diff --git a/processing/post/3Dvisualize.py b/processing/post/3Dvisualize.py
index 33100780e..c2e1c8404 100755
--- a/processing/post/3Dvisualize.py
+++ b/processing/post/3Dvisualize.py
@@ -274,7 +274,7 @@ parser.add_option('-v', '--vector', action='extend', dest='vector', type='string
                   help='list of vectors to visualize', metavar = '<string LIST>')
 parser.add_option('-t', '--tensor', action='extend', dest='tensor', type='string', \
                   help='list of tensors to visualize', metavar = '<string LIST>')
-parser.add_option('-d', '--deformation', dest='defgrad', type='string', \
+parser.add_option('-d', '--deformation', dest='defgrad', action='store', type='string', \
                   help='heading of deformation gradient columns [%default]', metavar = 'string')
 parser.add_option('--reference', dest='undeformed', action='store_true',\
                   help='map results to reference (undeformed) configuration [%default]')
@@ -290,15 +290,15 @@ parser.add_option('--points', dest='output_points', action='store_true', \
                   help='produce VTK points file [%default]')
 parser.add_option('--nopoints', dest='output_points', action='store_false', \
                   help='omit VTK points file')
-parser.add_option('--separator', dest='separator', type='string', \
+parser.add_option('--separator', dest='separator', action='store', type='string', \
                   help='data separator (t(ab), n(ewline), s(pace)) [%default]', metavar = 'string')
 parser.add_option('--scaling', dest='scaling', action='extend', type='string', \
                   help='scaling of fluctuation', metavar = '<float LIST>')
-parser.add_option('-u', '--unitlength', dest='unitlength', type='float', \
+parser.add_option('-u', '--unitlength', dest='unitlength', action='store', type='float', \
                   help='set unit length for 2D model [%default]', metavar = 'float')
-parser.add_option('--filenodalcoords', dest='filenodalcoords', type='string', \
+parser.add_option('--filenodalcoords', dest='filenodalcoords', action='store', type='string', \
                   help='ASCII table containing nodal coords', metavar = 'string')
-parser.add_option('--labelnodalcoords', dest='labelnodalcoords', type='string', nargs=3, \
+parser.add_option('--labelnodalcoords', dest='labelnodalcoords', action='store', type='string', nargs=3, \
                   help='labels of nodal coords in ASCII table %default', metavar = 'string string string')
 parser.add_option('-l', '--linear', dest='linearreconstruction', action='store_true',\
                   help='use linear reconstruction of geometry [%default]')
diff --git a/processing/post/addCauchy.py b/processing/post/addCauchy.py
index 3100cb0ea..5c8131d2b 100755
--- a/processing/post/addCauchy.py
+++ b/processing/post/addCauchy.py
@@ -21,9 +21,9 @@ deformation gradient and first Piola--Kirchhoff stress.
 """, version = string.replace(scriptID,'\n','\\n')
 )
 
-parser.add_option('-f','--defgrad',     dest='defgrad', type='string', metavar='string', \
+parser.add_option('-f','--defgrad',     dest='defgrad', action='store', type='string', metavar='string', \
                                         help='heading of columns containing deformation gradient [%default]')
-parser.add_option('-p','--stress',      dest='stress', type='string', metavar='string', \
+parser.add_option('-p','--stress',      dest='stress', action='store', type='string', metavar='string', \
                                         help='heading of columns containing first Piola--Kirchhoff stress [%default]')
 parser.set_defaults(defgrad = 'f')
 parser.set_defaults(stress = 'p')
diff --git a/processing/post/addCompatibilityMismatch.py b/processing/post/addCompatibilityMismatch.py
index 1bb5acd50..d14d85bad 100755
--- a/processing/post/addCompatibilityMismatch.py
+++ b/processing/post/addCompatibilityMismatch.py
@@ -24,9 +24,9 @@ parser.add_option('--no-shape','-s',    dest='noShape', action='store_false', \
                                         help='do not calcuate shape mismatch [%default]')
 parser.add_option('--no-volume','-v',   dest='noVolume', action='store_false', \
                                         help='do not calculate volume mismatch [%default]')
-parser.add_option('-c','--coordinates', dest='coords', type='string', metavar='string', \
+parser.add_option('-c','--coordinates', dest='coords', action='store', type='string', metavar='string', \
                                         help='column heading for coordinates [%default]')
-parser.add_option('-f','--deformation', dest='defgrad', type='string', metavar='string ', \
+parser.add_option('-f','--deformation', dest='defgrad', action='store', type='string', metavar='string ', \
                                         help='column heading for coordinates [%defgrad]')
 parser.set_defaults(noVolume = False)
 parser.set_defaults(noShape = False)
diff --git a/processing/post/addCurl.py b/processing/post/addCurl.py
index ed915bf03..8cc814799 100755
--- a/processing/post/addCurl.py
+++ b/processing/post/addCurl.py
@@ -22,7 +22,7 @@ Deals with both vector- and tensor-valued fields.
 """, version = string.replace(scriptID,'\n','\\n')
 )
 
-parser.add_option('-c','--coordinates', dest='coords', type='string', metavar='string', \
+parser.add_option('-c','--coordinates', dest='coords', action='store', type='string', metavar='string', \
                                         help='column heading for coordinates [%default]')
 parser.add_option('-v','--vector',      dest='vector', action='extend', type='string', metavar='<string LIST>', \
                                         help='heading of columns containing vector field values')
diff --git a/processing/post/addDeformedConfiguration.py b/processing/post/addDeformedConfiguration.py
index f9a5b3906..8215c6182 100755
--- a/processing/post/addDeformedConfiguration.py
+++ b/processing/post/addDeformedConfiguration.py
@@ -21,9 +21,9 @@ Operates on periodic ordered three-dimensional data sets.
 """, version = string.replace(scriptID,'\n','\\n')
 )
 
-parser.add_option('-c','--coordinates', dest='coords', type='string', metavar='string', \
+parser.add_option('-c','--coordinates', dest='coords', action='store', type='string', metavar='string', \
                                         help='column heading for coordinates [%default]')
-parser.add_option('-d','--defgrad',     dest='defgrad', type='string', metavar='string', \
+parser.add_option('-d','--defgrad',     dest='defgrad', action='store', type='string', metavar='string', \
                                         help='heading of columns containing tensor field values')
 parser.add_option('-l', '--linear',     dest='linearreconstruction', action='store_true',\
                                         help='use linear reconstruction of geometry [%default]')
diff --git a/processing/post/addDivergence.py b/processing/post/addDivergence.py
index 006f83112..04a0bc329 100755
--- a/processing/post/addDivergence.py
+++ b/processing/post/addDivergence.py
@@ -27,7 +27,7 @@ parser.add_option('--fdm',              dest='accuracy', action='extend', type='
                                         help='degree of central difference accuracy (%s)'%(','.join(accuracyChoices)))
 parser.add_option('--fft',              dest='fft', action='store_true', \
                                         help='calculate divergence in Fourier space')
-parser.add_option('-c','--coordinates', dest='coords', type='string', metavar = 'string', \
+parser.add_option('-c','--coordinates', dest='coords', action='store', type='string', metavar = 'string', \
                                         help='column heading for coordinates [%default]')
 parser.add_option('-v','--vector',      dest='vector', action='extend', type='string', metavar='<string LIST>', \
                                         help='heading of columns containing vector field values')
diff --git a/processing/post/addEuclideanDistance.py b/processing/post/addEuclideanDistance.py
index 324db7227..65245796f 100755
--- a/processing/post/addEuclideanDistance.py
+++ b/processing/post/addEuclideanDistance.py
@@ -1,39 +1,25 @@
 #!/usr/bin/env python
 # -*- coding: UTF-8 no BOM -*-
 
-import os,re,sys,math,numpy,string,damask
+import os,re,sys,math,string
+import numpy as np
+from optparse import OptionParser
 from scipy import ndimage
-from optparse import OptionParser, Option
-
-# -----------------------------
-class extendableOption(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)
+import damask
 
+scriptID = '$Id$'
+scriptName = scriptID.split()[1]
 
 def periodic_3Dpad(array, rimdim=(1,1,1)):
 
-  rimdim = numpy.array(rimdim,'i')
-  size = numpy.array(array.shape,'i')
-  padded = numpy.empty(size+2*rimdim,array.dtype)
+  rimdim = np.array(rimdim,'i')
+  size = np.array(array.shape,'i')
+  padded = np.empty(size+2*rimdim,array.dtype)
   padded[rimdim[0]:rimdim[0]+size[0],
          rimdim[1]:rimdim[1]+size[1],
          rimdim[2]:rimdim[2]+size[2]] = array
 
-  p = numpy.zeros(3,'i')
+  p = np.zeros(3,'i')
   for side in xrange(3):
     for p[(side+2)%3] in xrange(padded.shape[(side+2)%3]):
       for p[(side+1)%3] in xrange(padded.shape[(side+1)%3]):
@@ -56,7 +42,7 @@ features = [ \
            ]
 
 neighborhoods = {
-                  'neumann':numpy.array([
+                  'neumann':np.array([
                                         [-1, 0, 0],
                                         [ 1, 0, 0],
                                         [ 0,-1, 0],
@@ -64,7 +50,7 @@ neighborhoods = {
                                         [ 0, 0,-1],
                                         [ 0, 0, 1],
                                       ]),
-                  'moore':numpy.array([
+                  'moore':np.array([
                                         [-1,-1,-1],
                                         [ 0,-1,-1],
                                         [ 1,-1,-1],
@@ -95,22 +81,22 @@ neighborhoods = {
                                       ])
                 }
 
-parser = OptionParser(option_class=extendableOption, usage='%prog options [file[s]]', description = """
+parser = OptionParser(option_class=damask.extendableOption, usage='%prog options [file[s]]', description = """
 Add column(s) containing Euclidean distance to grain structural features:
 boundaries, triple lines, and quadruple points.
 
-""" + string.replace('$Id$','\n','\\n')
+""", version = string.replace(scriptID,'\n','\\n')
 )
 
-parser.add_option('-i','--identifier',  dest='id', action='store', type='string', \
-                                        help='heading of column containing grain identifier [%default]', \
-                                        metavar='<label>')
-parser.add_option('-t','--type',        dest='type', action='extend', type='string', \
+parser.add_option('-c','--coordinates', dest='coords', action='store', type='string', metavar='string', \
+                                        help='column heading for coordinates [%default]')
+parser.add_option('-i','--identifier',  dest='id', action='store', type='string', metavar = 'string', \
+                                        help='heading of column containing grain identifier [%default]')
+parser.add_option('-t','--type',        dest='type', action='extend', type='string', metavar='<string LIST>', \
                                         help='feature type (%s)'%(', '.join(map(lambda x:', '.join(x['names']),features))))
-parser.add_option('-n','--neighborhood',  dest='neigborhood', action='store', type='string', \
-                                        help='type of neighborhood (%s)'%(', '.join(neighborhoods.keys())), \
-                                        metavar='<int>')
-
+parser.add_option('-n','--neighborhood',dest='neigborhood', action='store', type='string', metavar='int', \
+                                        help='type of neighborhood (%s)'%(', '.join(neighborhoods.keys())))
+parser.set_defaults(coords = 'ip')
 parser.set_defaults(type = [])
 parser.set_defaults(id = 'texture')
 parser.set_defaults(neighborhood = 'neumann')
@@ -126,60 +112,61 @@ for i,feature in enumerate(features):
   for name in feature['names']:
     for type in options.type:
       if name.startswith(type):
-        feature_list.append(i)                            # remember valid features
+        feature_list.append(i)                                                                      # remember valid features
         break
 
-# ------------------------------------------ setup file handles ---------------------------------------  
+# ------------------------------------------ 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.stderr})
-
-# ------------------------------------------ loop over input files ---------------------------------------  
+for name in filenames:
+  if os.path.exists(name):
+    files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w'), 'croak':sys.stderr})
 
+# ------------------------------------------ loop over input files ---------------------------------
 for file in files:
-  if file['name'] != 'STDIN': file['croak'].write(file['name']+'\n')
+  file['croak'].write('\033[1m'+scriptName+'\033[0m: '+file['name']+'\n')
 
-  table = damask.ASCIItable(file['input'],file['output'],False)             # make unbuffered ASCII_table
-  table.head_read()                                                         # read ASCII header info
-  table.info_append(string.replace('$Id$','\n','\\n') + \
-                    '\t' + ' '.join(sys.argv[1:]))
+  table = damask.ASCIItable(file['input'],file['output'],False)                                     # make unbuffered ASCII_table
+  table.head_read()                                                                                 # read ASCII header info
+  table.info_append(string.replace(scriptID,'\n','\\n') + '\t' + ' '.join(sys.argv[1:]))
 
-# ------------------------------------------ assemble header ---------------------------------------  
+# --------------- figure out position of labels and coordinates ------------------------------------
+  try:
+    locationCol = table.labels.index('%s.x'%options.coords)                                         # columns containing location data
+  except ValueError:
+    file['croak'].write('no coordinate data found...\n'%key)
+    continue
 
   if options.id not in table.labels:
     file['croak'].write('column %s not found...\n'%options.id)
     continue
 
+# ------------------------------------------ assemble header --------------------------------------- 
   for feature in feature_list:
-    table.labels_append('ED_%s(%s)'%(features[feature]['names'][0],options.id))     # extend ASCII header with new labels
+    table.labels_append('ED_%s(%s)'%(features[feature]['names'][0],options.id))                     # extend ASCII header with new labels
 
   table.head_write()
 
 # ------------------------------------------ process data ---------------------------------------   
   
-  table.data_readArray(['ip.x','ip.y','ip.z',options.id])
+  table.data_readArray([options.coords+'.x',options.coords+'.y',options.coords+'.z',options.id])
 
   grid = [{},{},{}]
   for i in xrange(len(table.data)):
     for j in xrange(3):
       grid[j][str(table.data[i,j])] = True
 
-  resolution = numpy.array(map(len,grid),'i')
+  resolution = np.array(map(len,grid),'i')
   unitlength = 0.0
   for i,r in enumerate(resolution):
     if r > 1: unitlength = max(unitlength,(max(map(float,grid[i].keys()))-min(map(float,grid[i].keys())))/(r-1.0))
 
   neighborhood = neighborhoods[options.neighborhood]
-  convoluted = numpy.empty([len(neighborhood)]+list(resolution+2),'i')
-  microstructure = periodic_3Dpad(numpy.array(table.data[:,3].reshape(resolution),'i'))
+  convoluted = np.empty([len(neighborhood)]+list(resolution+2),'i')
+  microstructure = periodic_3Dpad(np.array(table.data[:,3].reshape(resolution),'i'))
   
   for i,p in enumerate(neighborhood):
-    stencil = numpy.zeros((3,3,3),'i')
+    stencil = np.zeros((3,3,3),'i')
     stencil[1,1,1] = -1
     stencil[p[0]+1,
             p[1]+1,
@@ -187,36 +174,34 @@ for file in files:
 
     convoluted[i,:,:,:] = ndimage.convolve(microstructure,stencil)
   
-  distance = numpy.ones((len(feature_list),resolution[0],resolution[1],resolution[2]),'d')
+  distance = np.ones((len(feature_list),resolution[0],resolution[1],resolution[2]),'d')
   
-  convoluted = numpy.sort(convoluted,axis=0)
-  uniques = numpy.zeros(resolution)
-  check = numpy.empty(resolution)
-  check[:,:,:] = numpy.nan
+  convoluted = np.sort(convoluted,axis=0)
+  uniques = np.zeros(resolution)
+  check = np.empty(resolution)
+  check[:,:,:] = np.nan
   for i in xrange(len(neighborhood)):
-    uniques += numpy.where(convoluted[i,1:-1,1:-1,1:-1] == check,0,1)
+    uniques += np.where(convoluted[i,1:-1,1:-1,1:-1] == check,0,1)
     check = convoluted[i,1:-1,1:-1,1:-1]
   for i,feature_id in enumerate(feature_list):
-    distance[i,:,:,:] = numpy.where(uniques > features[feature_id]['aliens'],0.0,1.0)
+    distance[i,:,:,:] = np.where(uniques > features[feature_id]['aliens'],0.0,1.0)
   
   for i in xrange(len(feature_list)):
     distance[i,:,:,:] = ndimage.morphology.distance_transform_edt(distance[i,:,:,:])*[unitlength]*3
   distance.shape = (len(feature_list),resolution.prod())
   
+# ------------------------------------------ process data ---------------------------------------
   table.data_rewind()
   l = 0
   while table.data_read():
     for i in xrange(len(feature_list)):
-      table.data_append(distance[i,l])                                      # add all distance fields
-    table.data_write()                                                      # output processed line
+      table.data_append(distance[i,l])                                                              # add all distance fields
+    outputAlive = table.data_write()                                                                # output processed line
     l += 1
-    
+
 # ------------------------------------------ output result ---------------------------------------  
+  outputAlive and table.output_flush()                                                              # just in case of buffered ASCII table
 
-  table.output_flush()                                                      # just in case of buffered ASCII table
-
-  if file['name'] != 'STDIN':
-    file['input'].close()                                                   # close input ASCII table
-    file['output'].close()                                                  # close output ASCII table
-    os.rename(file['name']+'_tmp',file['name'])                             # overwrite old one with tmp new
-    
\ No newline at end of file
+  file['input'].close()                                                                             # close input ASCII table (works for stdin)
+  file['output'].close()                                                                            # close output ASCII table (works for stdout)
+  os.rename(file['name']+'_tmp',file['name'])                                                       # overwrite old one with tmp new
diff --git a/processing/post/addIPFcolor.py b/processing/post/addIPFcolor.py
index a89dcb088..362de1016 100755
--- a/processing/post/addIPFcolor.py
+++ b/processing/post/addIPFcolor.py
@@ -1,56 +1,43 @@
 #!/usr/bin/env python
 # -*- coding: UTF-8 no BOM -*-
 
-import os,sys,string,re,math,numpy
-import damask
+import os,re,sys,math,string
+import numpy as np
 from collections import defaultdict
-from optparse import OptionParser, OptionGroup, Option, SUPPRESS_HELP
+from optparse import OptionParser
+import damask
 
 scriptID = '$Id$'
 scriptName = scriptID.split()[1]
 
-#--------------------------------------------------------------------------------------------------
-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",)
+# --------------------------------------------------------------------
+#                                MAIN
+# --------------------------------------------------------------------
 
-    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)
-
-
-parser = OptionParser(option_class=extendedOption, usage='%prog options [file[s]]', description = """
+parser = OptionParser(option_class=damask.extendableOption, usage='%prog options [file[s]]', description = """
 Add RGB color value corresponding to TSL-OIM scheme for inverse pole figures.
-""" + string.replace(scriptID,'\n','\\n')
+
+""", version = string.replace(scriptID,'\n','\\n')
 )
 
-parser.add_option('-p', '--pole', dest='pole', type='float', nargs=3, metavar='X Y Z',
-                  help = 'lab frame direction for inverse pole figure %default')
-parser.add_option('-s', '--symmetry', dest='symmetry', type='string',
-                  help = 'crystal symmetry [%default]')
-parser.add_option('-e', '--eulers',   dest='eulers', type='string', metavar='LABEL',
-                  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='LABEL',
-                  help = 'orientation matrix label')
-parser.add_option('-a',               dest='a', type='string', metavar='LABEL',
-                  help = 'crystal frame a vector label')
-parser.add_option('-b',               dest='b', type='string', metavar='LABEL',
-                  help = 'crystal frame b vector label')
-parser.add_option('-c',               dest='c', type='string', metavar='LABEL',
-                  help = 'crystal frame c vector label')
+parser.add_option('-p', '--pole',       dest='pole', type='float', nargs=3, metavar='X Y Z',
+                                        help = 'lab frame direction for inverse pole figure %default')
+parser.add_option('-s', '--symmetry',   dest='symmetry', type='string',
+                                        help = 'crystal symmetry [%default]')
+parser.add_option('-e', '--eulers',     dest='eulers', type='string', metavar='LABEL',
+                                        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='LABEL',
+                                        help = 'orientation matrix label')
+parser.add_option('-a',                 dest='a', type='string', metavar='LABEL',
+                                        help = 'crystal frame a vector label')
+parser.add_option('-b',                 dest='b', type='string', metavar='LABEL',
+                                        help = 'crystal frame b vector label')
+parser.add_option('-c',                 dest='c', type='string', metavar='LABEL',
+                                        help = 'crystal frame c vector label')
 parser.add_option('-q', '--quaternion', dest='quaternion', type='string', metavar='LABEL',
-                  help = 'quaternion label')
+                                        help = 'quaternion label')
 
 parser.set_defaults(pole = [0.0,0.0,1.0])
 parser.set_defaults(symmetry = 'cubic')
@@ -75,8 +62,8 @@ if options.matrix     != None:  datainfo['tensor']['label'] += [options.matrix];
 if options.quaternion != None:  datainfo['quaternion']['label'] += [options.quaternion];        input = 'quaternion'
 
 toRadians = math.pi/180.0 if options.degrees else 1.0                                                                               # rescale degrees to radians
-pole = numpy.array(options.pole)
-pole /= numpy.linalg.norm(pole)
+pole = np.array(options.pole)
+pole /= np.linalg.norm(pole)
 
 # ------------------------------------------ setup file handles ---------------------------------------  
 
@@ -124,15 +111,15 @@ for file in files:
   while table.data_read():                                                  # read next data line of ASCII table
 
     if input == 'eulers':
-      o = damask.Orientation(Eulers=toRadians*numpy.array(map(float,table.data[column['vector'][options.eulers]:\
+      o = damask.Orientation(Eulers=toRadians*np.array(map(float,table.data[column['vector'][options.eulers]:\
                                                                                column['vector'][options.eulers]+datainfo['vector']['len']])),
                              symmetry=options.symmetry).reduced()
     elif input == 'matrix':
-      o = damask.Orientation(matrix=numpy.array([map(float,table.data[column['tensor'][options.matrix]:\
+      o = damask.Orientation(matrix=np.array([map(float,table.data[column['tensor'][options.matrix]:\
                                                                       column['tensor'][options.matrix]+datainfo['tensor']['len']])]),
                              symmetry=options.symmetry).reduced()
     elif input == 'frame':
-      o = damask.Orientation(matrix=numpy.array([map(float,table.data[column['vector'][options.a]:\
+      o = damask.Orientation(matrix=np.array([map(float,table.data[column['vector'][options.a]:\
                                                                       column['vector'][options.a]+datainfo['vector']['len']] + \
                                                            table.data[column['vector'][options.b]:\
                                                                       column['vector'][options.b]+datainfo['vector']['len']] + \
@@ -141,19 +128,17 @@ for file in files:
                                                     )]).reshape(3,3),
                              symmetry=options.symmetry).reduced()
     elif input == 'quaternion':
-      o = damask.Orientation(quaternion=numpy.array(map(float,table.data[column['quaternion'][options.quaternion]:\
+      o = damask.Orientation(quaternion=np.array(map(float,table.data[column['quaternion'][options.quaternion]:\
                                                                           column['quaternion'][options.quaternion]+datainfo['quaternion']['len']])),
                              symmetry=options.symmetry).reduced()
 
     table.data_append(o.IPFcolor(pole))
-
-    table.data_write()                                                      # output processed line
+    outputAlive = table.data_write()                                                                # output processed line
 
 # ------------------------------------------ output result ---------------------------------------  
+  outputAlive and table.output_flush()                                                              # just in case of buffered ASCII table
 
-  table.output_flush()                                                      # just in case of buffered ASCII table
-
+  file['input'].close()                                                                             # close input ASCII table (works for stdin)
+  file['output'].close()                                                                            # close output ASCII table (works for stdout)
   if file['name'] != 'STDIN':
-    file['input'].close()                                                   # close input ASCII table
-    file['output'].close()                                                  # close output ASCII table
-    os.rename(file['name']+'_tmp',file['name'])                             # overwrite old one with tmp new
+    os.rename(file['name']+'_tmp',file['name'])                                                     # overwrite old one with tmp new