using class

needs more memory, but should be faster and is better readable

processing/post/addGradient.py

@@ -52,7 +52,7 @@ def gradFFT(geomdim,field):
 #                                MAIN
 # --------------------------------------------------------------------
 
-parser = OptionParser(option_class=damask.extendableOption, usage='%prog option [ASCIItable(s)]', description = """
+parser = OptionParser(option_class=damask.extendableOption, usage='%prog options [ASCIItable(s)]', description = """
 Add column(s) containing gradient of requested column(s).
 Operates on periodic ordered three-dimensional data sets
 of vector and scalar fields.

processing/pre/geom_pack.py

@@ -1,112 +1,82 @@
 #!/usr/bin/env python3
-# -*- coding: UTF-8 no BOM -*-
 
-import os,sys
+import os
-import numpy as np
+import sys
 from optparse import OptionParser
+
 import damask
 
+
 scriptName = os.path.splitext(os.path.basename(__file__))[0]
 scriptID   = ' '.join([scriptName,damask.version])
 
+
 #--------------------------------------------------------------------------------------------------
 #                                MAIN
 #--------------------------------------------------------------------------------------------------
 
 parser = OptionParser(option_class=damask.extendableOption, usage='%prog [geomfile(s)]', description = """
-compress geometry files with ranges "a to b" and/or multiples "n of x".
+Pack ranges to "a to b" and/or multiples to "n of x".
 
 """, version = scriptID)
 
 (options, filenames) = parser.parse_args()
 
-# --- loop over input files -------------------------------------------------------------------------
 
 if filenames == []: filenames = [None]
 
 for name in filenames:
-  try:
-    table = damask.ASCIItable(name = name,
-                              buffered = False, labeled = False)
-  except: continue
   damask.util.report(scriptName,name)
 
-# --- interpret header ----------------------------------------------------------------------------
+  if name is None:
+    virt_file = StringIO(''.join(sys.stdin.read()))
+    geom = damask.Geom.from_file(virt_file)
+  else:
+    geom = damask.Geom.from_file(name)
+  damask.util.croak(geom)
+  microstructure = geom.get_microstructure().flatten('F')
 
-  table.head_read()
-  info,extra_header = table.head_getGeom()
-  damask.util.report_geom(info)
- 
-  errors = []
-  if np.any(info['grid'] < 1):    errors.append('invalid grid a b c.')
-  if np.any(info['size'] <= 0.0): errors.append('invalid size x y z.')
-  if errors != []:
-    damask.util.croak(errors)
-    table.close(dismiss = True)
-    continue
-
-# --- write header ---------------------------------------------------------------------------------
-
-  table.labels_clear()
-  table.info_clear()
-  table.info_append(extra_header+[
-    scriptID + ' ' + ' '.join(sys.argv[1:]),
-    "grid\ta {grid[0]}\tb {grid[1]}\tc {grid[2]}".format(grid=info['grid']),
-    "size\tx {size[0]}\ty {size[1]}\tz {size[2]}".format(size=info['size']),
-    "origin\tx {origin[0]}\ty {origin[1]}\tz {origin[2]}".format(origin=info['origin']),
-    "homogenization\t{homog}".format(homog=info['homogenization']),
-    "microstructures\t{microstructures}".format(microstructures=info['microstructures']),
-    ])
-  table.head_write()
   
-# --- write packed microstructure information -----------------------------------------------------
+  compressType = None
-
-  compressType = ''
   former = start = -1
   reps = 0
 
-  outputAlive = True
+  for current in microstructure:
-  while outputAlive and table.data_read():                                                          # read next data line of ASCII table
+    if abs(current - former) == 1 and (start - current) == reps*(former - current):
-    items = table.data
+      compressType = 'to'
-    if len(items) > 2:
+      reps += 1
-      if   items[1].lower() == 'of': items = [int(items[2])]*int(items[0])
+    elif current == former and start == former:
-      elif items[1].lower() == 'to': items = range(int(items[0]),1+int(items[2]))
+      compressType = 'of'
-      else:                          items = map(int,items)
+      reps += 1
-    else:                            items = map(int,items)
+    else:
+      if   compressType == None:
+        out = []
+      elif compressType == '.':
+        out.append('{}\n'.format(former))
+      elif compressType == 'to':
+        out.append('{} to {}\n'.format(start,former))
+      elif compressType == 'of':
+        out.append('{} of {}\n'.format(reps,former))
 
-    for current in items:
+      compressType = '.'
-      if abs(current - former) == 1 and (start - current) == reps*(former - current):
+      start = current
-        compressType = 'to'
+      reps = 1
-        reps += 1
-      elif current == former and start == former:
-        compressType = 'of'
-        reps += 1
-      else:
-        if   compressType == '':
-          table.data = []
-        elif compressType == '.':
-          table.data = [former]
-        elif compressType == 'to':
-          table.data = [start,'to',former]
-        elif compressType == 'of':
-          table.data = [reps,'of',former]
 
-        outputAlive = table.data_write(delimiter = ' ')                                             # output processed line
+    former = current
-
+   
-        compressType = '.'
+  if compressType == '.':
-        start = current
+    out.append('{}\n'.format(former))
-        reps = 1
+  elif compressType == 'to':
-
+    out.append('{} to {}\n'.format(start,former))
-      former = current
+  elif compressType == 'of':
-
+    out.append('{} of {}\n'.format(reps,former))
-  table.data = {
+ 
-                '.' : [former],
+  geom.add_comment(scriptID + ' ' + ' '.join(sys.argv[1:]))
-                'to': [start,'to',former],
+  comments = geom.get_comments()
-                'of': [reps,'of',former],
+  with open(name,'w') as f:
-               }[compressType]
+    f.write('{} header\n'.format(3+len(comments)))
-
+    f.writelines(["{}\n".format(comment) for comment in comments])
-  outputAlive = table.data_write(delimiter = ' ')                                                   # output processed line
+    f.write('grid a {} b {} c {}\n'.format(*geom.get_grid()))
-
+    f.write('size x {} y {} z {}\n'.format(*geom.get_size()))
-# --- output finalization --------------------------------------------------------------------------
+    f.write('homogenization {}\n'.format(geom.get_homogenization()))
-
+    f.writelines(out)
-  table.close()                                                                                     # close ASCII table

processing/pre/geom_unpack.py

@@ -34,10 +34,10 @@ for name in filenames:
     geom = damask.Geom.from_file(virt_file)
   else:
     geom = damask.Geom.from_file(name)
-
+  damask.util.croak(geom)
+  
   geom.add_comment(scriptID + ' ' + ' '.join(sys.argv[1:]))
   
-  damask.util.croak(geom)
   if name is None:
     sys.stdout.write(str(geom.show()))
   else: