223031012
/
DAMASK_EICMD
mirror of https://github.com/achalhp/DAMASK_EICMD.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

improved file handling etc. to follow newest style

This commit is contained in:
Martin Diehl 2014-07-16 16:41:04 +00:00
parent 11a4b59c69
commit 2f0ecdf7e8
2 changed files with 108 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
processing/post/addCurl.py
View File

@ -3,6 +3,7 @@
import os,re,sys,math,string import os,re,sys,math,string
import numpy as np import numpy as np
from collections import defaultdict
from optparse import OptionParser from optparse import OptionParser
import damask import damask
@ -18,10 +19,9 @@ Add column(s) containing curl of requested column(s).
Operates on periodic ordered three-dimensional data sets. Operates on periodic ordered three-dimensional data sets.
Deals with both vector- and tensor-valued fields. Deals with both vector- and tensor-valued fields.
""", version=string.replace('$Id$','\n','\\n') """, version = string.replace(scriptID,'\n','\\n')
) )
parser.add_option('-c','--coordinates', dest='coords', type='string', metavar='string', \ parser.add_option('-c','--coordinates', dest='coords', type='string', metavar='string', \
help='column heading for coordinates [%default]') help='column heading for coordinates [%default]')
parser.add_option('-v','--vector', dest='vector', action='extend', type='string', metavar='<string LIST>', \ parser.add_option('-v','--vector', dest='vector', action='extend', type='string', metavar='<string LIST>', \
@ -49,19 +49,15 @@ if options.tensor != None: datainfo['tensor']['label'] += options.tensor
# ------------------------------------------ setup file handles ------------------------------------ # ------------------------------------------ setup file handles ------------------------------------
files = [] files = []
if filenames == []: for name in filenames:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout, 'croak':sys.stderr}) if os.path.exists(name):
else: files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w'), 'croak':sys.stderr})
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 ------------------------------------------------------------------------ #--- loop over input files ------------------------------------------------------------------------
for file in files: for file in files:
if file['name'] != 'STDIN': file['croak'].write('\033[1m'+scriptName+'\033[0m: '+file['name']+'\n') file['croak'].write('\033[1m'+scriptName+'\033[0m: '+file['name']+'\n')
else: file['croak'].write('\033[1m'+scriptName+'\033[0m\n')
table = damask.ASCIItable(file['input'],file['output'],False) # make unbuffered ASCII_table table = damask.ASCIItable(file['input'],file['output'],True) # make unbuffered ASCII_table
table.head_read() # read ASCII header info table.head_read() # read ASCII header info
table.info_append(string.replace(scriptID,'\n','\\n') + '\t' + ' '.join(sys.argv[1:])) table.info_append(string.replace(scriptID,'\n','\\n') + '\t' + ' '.join(sys.argv[1:]))
@ -73,29 +69,27 @@ for file in files:
continue continue
grid = [{},{},{}] grid = [{},{},{}]
while table.data_read(): # read next data line of ASCII table while table.data_read(): # read next data line of ASCII table
for j in xrange(3): for j in xrange(3):
grid[j][str(table.data[locationCol+j])] = True # remember coordinate along x,y,z grid[j][str(table.data[locationCol+j])] = True # remember coordinate along x,y,z
resolution = np.array([len(grid[0]),\ resolution = np.array([len(grid[0]),\
len(grid[1]),\ len(grid[1]),\
len(grid[2]),],'i') # resolution is number of distinct coordinates found len(grid[2]),],'i') # resolution is number of distinct coordinates found
dimension = resolution/np.maximum(np.ones(3,'d'),resolution-1.0)* \ dimension = resolution/np.maximum(np.ones(3,'d'),resolution-1.0)* \
np.array([max(map(float,grid[0].keys()))-min(map(float,grid[0].keys())),\ np.array([max(map(float,grid[0].keys()))-min(map(float,grid[0].keys())),\
max(map(float,grid[1].keys()))-min(map(float,grid[1].keys())),\ max(map(float,grid[1].keys()))-min(map(float,grid[1].keys())),\
max(map(float,grid[2].keys()))-min(map(float,grid[2].keys())),\ max(map(float,grid[2].keys()))-min(map(float,grid[2].keys())),\
],'d') # dimension from bounding box, corrected for cell-centeredness ],'d') # dimension from bounding box, corrected for cell-centeredness
if resolution[2] == 1: if resolution[2] == 1:
dimension[2] = min(dimension[:2]/resolution[:2]) dimension[2] = min(dimension[:2]/resolution[:2])
N = resolution.prod() N = resolution.prod()
# --------------- figure out columns to process # --------------- figure out columns to process --------------------------------------------------
active = {} active = defaultdict(list)
column = {} column = defaultdict(dict)
values = {} values = defaultdict(dict)
curl = {} curl = defaultdict(dict)
missingColumns = False
head = []
for datatype,info in datainfo.items(): for datatype,info in datainfo.items():
for label in info['label']: for label in info['label']:
@ -104,28 +98,28 @@ for file in files:
if key not in table.labels: if key not in table.labels:
sys.stderr.write('column %s not found...\n'%key) sys.stderr.write('column %s not found...\n'%key)
else: else:
if datatype not in active: active[datatype] = []
if datatype not in column: column[datatype] = {}
if datatype not in values: values[datatype] = {}
if datatype not in curl: curl[datatype] = {}
active[datatype].append(label) active[datatype].append(label)
column[datatype][label] = table.labels.index(key) # remember columns of requested data column[datatype][label] = table.labels.index(key) # remember columns of requested data
values[datatype][label] = np.array([0.0 for i in xrange(N*datainfo[datatype]['len'])]).\ values[datatype][label] = np.array([0.0 for i in xrange(N*datainfo[datatype]['len'])]).\
reshape(list(resolution)+[datainfo[datatype]['len']//3,3]) reshape(list(resolution)+[datainfo[datatype]['len']//3,3])
curl[datatype][label] = np.array([0.0 for i in xrange(N*datainfo[datatype]['len'])]).\ curl[datatype][label] = np.array([0.0 for i in xrange(N*datainfo[datatype]['len'])]).\
reshape(list(resolution)+[datainfo[datatype]['len']//3,3]) reshape(list(resolution)+[datainfo[datatype]['len']//3,3])
table.labels_append(['%i_curlFFT(%s)'%(i+1,label)
for i in xrange(datainfo[datatype]['len'])]) # extend ASCII header with new labels
if missingColumns:
continue
# ------------------------------------------ assemble header --------------------------------------- # ------------------------------------------ assemble header ---------------------------------------
for datatype,info in datainfo.items():
for label in info['label']:
table.labels_append(['%i_curlFFT(%s)'%(i+1,label)
for i in xrange(datainfo[datatype]['len'])]) # extend ASCII header with new labels
table.head_write() table.head_write()
# ------------------------------------------ read value field -------------------------------------- # ------------------------------------------ read value field --------------------------------------
table.data_rewind() table.data_rewind()
idx = 0 idx = 0
while table.data_read(): # read next data line of ASCII table while table.data_read(): # read next data line of ASCII table
(x,y,z) = damask.gridLocation(idx,resolution) # figure out (x,y,z) position from line count (x,y,z) = damask.util.gridLocation(idx,resolution) # figure out (x,y,z) position from line count
idx += 1 idx += 1
for datatype,labels in active.items(): # loop over vector,tensor for datatype,labels in active.items(): # loop over vector,tensor
for label in labels: # loop over all requested curls for label in labels: # loop over all requested curls
@ -141,10 +135,10 @@ for file in files:
# ------------------------------------------ process data --------------------------------------- # ------------------------------------------ process data ---------------------------------------
table.data_rewind() table.data_rewind()
outputAlive = True
idx = 0 idx = 0
outputAlive = True
while outputAlive and table.data_read(): # read next data line of ASCII table while outputAlive and table.data_read(): # read next data line of ASCII table
(x,y,z) = damask.gridLocation(idx,resolution) # figure out (x,y,z) position from line count (x,y,z) = damask.util.gridLocation(idx,resolution) # figure out (x,y,z) position from line count
idx += 1 idx += 1
for datatype,labels in active.items(): # loop over vector,tensor for datatype,labels in active.items(): # loop over vector,tensor
for label in labels: # loop over all requested norms for label in labels: # loop over all requested norms
@ -152,11 +146,9 @@ for file in files:
outputAlive = table.data_write() # output processed line outputAlive = table.data_write() # output processed line
# ------------------------------------------ output result --------------------------------------- # ------------------------------------------ output result ---------------------------------------
outputAlive and table.output_flush() # just in case of buffered ASCII table outputAlive and table.output_flush() # just in case of buffered ASCII table
file['input'].close() # close input ASCII table (works for stdin) file['input'].close() # close input ASCII table (works for stdin)
file['output'].close() # close output ASCII table (works for stdout) file['output'].close() # close output ASCII table (works for stdout)
if file['name'] != 'STDIN': 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

197
processing/post/addDivergence.py
View File

@ -1,64 +1,38 @@
#!/usr/bin/env python #!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*- # -*- coding: UTF-8 no BOM -*-
import os,re,sys,math,string,numpy,damask import os,re,sys,math,string
from optparse import OptionParser, Option import numpy as np
from collections import defaultdict
# ----------------------------- from optparse import OptionParser
class extendableOption(Option): import damask
# -----------------------------
# 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)
def location(idx,res):
return ( idx % res[0], \
( idx // res[0]) % res[1], \
( idx // res[0] // res[1]) % res[2] )
def index(location,res):
return ( location[0] % res[0] + \
( location[1] % res[1]) * res[0] + \
( location[2] % res[2]) * res[1] * res[0] )
scriptID = '$Id$'
scriptName = scriptID.split()[1]
accuracyChoices = ['2','4','6','8']
# -------------------------------------------------------------------- # --------------------------------------------------------------------
# MAIN # MAIN
# -------------------------------------------------------------------- # --------------------------------------------------------------------
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 divergence of requested column(s). Add column(s) containing divergence of requested column(s).
Operates on periodic ordered three-dimensional data sets. Operates on periodic ordered three-dimensional data sets.
Deals with both vector- and tensor-valued fields. Deals with both vector- and tensor-valued fields.
""" + string.replace('$Id$','\n','\\n') """, version = string.replace(scriptID,'\n','\\n')
) )
accuracyChoices = ['2','4','6','8'] parser.add_option('--fdm', dest='accuracy', action='extend', type='string', metavar='<int LIST>', \
parser.add_option('--fdm', dest='accuracy', action='extend', type='string', \
help='degree of central difference accuracy (%s)'%(','.join(accuracyChoices))) help='degree of central difference accuracy (%s)'%(','.join(accuracyChoices)))
parser.add_option('--fft', dest='fft', action='store_true', \ parser.add_option('--fft', dest='fft', action='store_true', \
help='calculate divergence in Fourier space') help='calculate divergence in Fourier space')
parser.add_option('-c','--coordinates', dest='coords', type='string',\ parser.add_option('-c','--coordinates', dest='coords', type='string', metavar = 'string', \
help='column heading for coordinates [%default]') help='column heading for coordinates [%default]')
parser.add_option('-v','--vector', dest='vector', action='extend', type='string', \ parser.add_option('-v','--vector', dest='vector', action='extend', type='string', metavar='<string LIST>', \
help='heading of columns containing vector field values') help='heading of columns containing vector field values')
parser.add_option('-t','--tensor', dest='tensor', action='extend', type='string', \ parser.add_option('-t','--tensor', dest='tensor', action='extend', type='string', metavar='<string LIST>', \
help='heading of columns containing tensor field values') help='heading of columns containing tensor field values')
parser.set_defaults(coords = 'ip') parser.set_defaults(coords = 'ip')
parser.set_defaults(accuracy = []) parser.set_defaults(accuracy = [])
parser.set_defaults(fft = False) parser.set_defaults(fft = False)
@ -87,60 +61,49 @@ datainfo = { # lis
if options.vector != None: datainfo['vector']['label'] += options.vector if options.vector != None: datainfo['vector']['label'] += options.vector
if options.tensor != None: datainfo['tensor']['label'] += options.tensor if options.tensor != None: datainfo['tensor']['label'] += options.tensor
# ------------------------------------------ setup file handles --------------------------------------- # ------------------------------------------ setup file handles ------------------------------------
files = [] files = []
if filenames == []: for name in filenames:
files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout}) if os.path.exists(name):
else: files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w'), 'croak':sys.stderr})
for name in filenames:
if os.path.exists(name):
files.append({'name':name, 'input':open(name), 'output':open(name+'_tmp','w')})
# ------------------------------------------ loop over input files ---------------------------------------
#--- loop over input files ------------------------------------------------------------------------
for file in files: for file in files:
if file['name'] != 'STDIN': print file['name'], file['croak'].write('\033[1m'+scriptName+'\033[0m: '+file['name']+'\n')
table = damask.ASCIItable(file['input'],file['output'],False) # make unbuffered ASCII_table table = damask.ASCIItable(file['input'],file['output'],True) # make unbuffered ASCII_table
table.head_read() # read ASCII header info table.head_read() # read ASCII header info
table.info_append(string.replace('$Id$','\n','\\n') + \ table.info_append(string.replace(scriptID,'\n','\\n') + '\t' + ' '.join(sys.argv[1:]))
'\t' + ' '.join(sys.argv[1:]))
# --------------- figure out dimension and resolution # --------------- figure out dimension and resolution ----------------------------------------------
try: try:
locationCol = table.labels.index('%s.x'%options.coords) # columns containing location data locationCol = table.labels.index('%s.x'%options.coords) # columns containing location data
except ValueError: except ValueError:
print 'no coordinate data found...' file['croak'].write('no coordinate data found...\n'%key)
continue continue
grid = [{},{},{}] grid = [{},{},{}]
while table.data_read(): # read next data line of ASCII table while table.data_read(): # read next data line of ASCII table
for j in xrange(3): for j in xrange(3):
grid[j][str(table.data[locationCol+j])] = True # remember coordinate along x,y,z grid[j][str(table.data[locationCol+j])] = True # remember coordinate along x,y,z
resolution = numpy.array([len(grid[0]),\ resolution = np.array([len(grid[0]),\
len(grid[1]),\ len(grid[1]),\
len(grid[2]),],'i') # resolution is number of distinct coordinates found len(grid[2]),],'i') # resolution is number of distinct coordinates found
dimension = resolution/numpy.maximum(numpy.ones(3,'d'),resolution-1.0)* \ dimension = resolution/np.maximum(np.ones(3,'d'),resolution-1.0)* \
numpy.array([max(map(float,grid[0].keys()))-min(map(float,grid[0].keys())),\ np.array([max(map(float,grid[0].keys()))-min(map(float,grid[0].keys())),\
max(map(float,grid[1].keys()))-min(map(float,grid[1].keys())),\ max(map(float,grid[1].keys()))-min(map(float,grid[1].keys())),\
max(map(float,grid[2].keys()))-min(map(float,grid[2].keys())),\ max(map(float,grid[2].keys()))-min(map(float,grid[2].keys())),\
],'d') # dimension from bounding box, corrected for cell-centeredness ],'d') # dimension from bounding box, corrected for cell-centeredness
if resolution[2] == 1: if resolution[2] == 1:
dimension[2] = min(dimension[:2]/resolution[:2]) dimension[2] = min(dimension[:2]/resolution[:2])
N = resolution.prod() N = resolution.prod()
print '\t%s @ %s'%(dimension,resolution)
# --------------- figure out columns to process --------------------------------------------------
# --------------- figure out columns to process active = defaultdict(list)
active = {} column = defaultdict(dict)
column = {} values = defaultdict(dict)
values = {} divergence = defaultdict(dict)
divergence = {} missingColumns = False
head = []
for datatype,info in datainfo.items(): for datatype,info in datainfo.items():
for label in info['label']: for label in info['label']:
@ -149,71 +112,67 @@ for file in files:
if key not in table.labels: if key not in table.labels:
sys.stderr.write('column %s not found...\n'%key) sys.stderr.write('column %s not found...\n'%key)
else: else:
if datatype not in active: active[datatype] = []
if datatype not in column: column[datatype] = {}
if datatype not in values: values[datatype] = {}
if datatype not in divergence: divergence[datatype] = {}
if label not in divergence[datatype]: divergence[datatype][label] = {}
active[datatype].append(label) active[datatype].append(label)
column[datatype][label] = table.labels.index(key) # remember columns of requested data column[datatype][label] = table.labels.index(key) # remember columns of requested data
values[datatype][label] = numpy.array([0.0 for i in xrange(N*datainfo[datatype]['len'])]).\ values[datatype][label] = np.array([0.0 for i in xrange(N*datainfo[datatype]['len'])]).\
reshape(list(resolution)+[datainfo[datatype]['len']//3,3]) reshape(list(resolution)+[datainfo[datatype]['len']//3,3])
if label not in divergence[datatype]: divergence[datatype][label] = {}
for accuracy in options.accuracy: for accuracy in options.accuracy:
divergence[datatype][label][accuracy] = numpy.array([0.0 for i in xrange(N*datainfo[datatype]['len']//3)]).\ divergence[datatype][label][accuracy] = np.array([0.0 for i in xrange(N*datainfo[datatype]['len']//3)]).\
reshape(list(resolution)+[datainfo[datatype]['len']//3]) reshape(list(resolution)+[datainfo[datatype]['len']//3])
if datatype == 'vector': # extend ASCII header with new labels
table.labels_append(['div%s(%s)'%(accuracy,label)])
if datatype == 'tensor':
table.labels_append(['%i_div%s(%s)'%(i+1,accuracy,label) for i in xrange(3)])
if missingColumns:
continue
# ------------------------------------------ assemble header --------------------------------------- # ------------------------------------------ assemble header ---------------------------------------
for datatype,info in datainfo.items():
for label in info['label']:
for accuracy in options.accuracy:
if datatype == 'vector': # extend ASCII header with new labels
table.labels_append(['div%s(%s)'%(accuracy,label)])
if datatype == 'tensor':
table.labels_append(['%i_div%s(%s)'%(i+1,accuracy,label) for i in xrange(3)])
table.head_write() table.head_write()
# ------------------------------------------ read value field --------------------------------------- # ------------------------------------------ read value field --------------------------------------
table.data_rewind() table.data_rewind()
idx = 0 idx = 0
while table.data_read(): # read next data line of ASCII table while table.data_read(): # read next data line of ASCII table
(x,y,z) = location(idx,resolution) # figure out (x,y,z) position from line count (x,y,z) = damask.util.gridLocation(idx,resolution) # figure out (x,y,z) position from line count
idx += 1 idx += 1
for datatype,labels in active.items(): # loop over vector,tensor for datatype,labels in active.items(): # loop over vector,tensor
for label in labels: # loop over all requested curls for label in labels: # loop over all requested curls
values[datatype][label][x,y,z] = numpy.array( values[datatype][label][x,y,z] = np.array(
map(float,table.data[column[datatype][label]: map(float,table.data[column[datatype][label]:
column[datatype][label]+datainfo[datatype]['len']]),'d').reshape(datainfo[datatype]['len']//3,3) column[datatype][label]+datainfo[datatype]['len']]),'d') \
# ------------------------------------------ process value field --------------------------------------- .reshape(datainfo[datatype]['len']//3,3)
for datatype,labels in active.items(): # loop over vector,tensor # ------------------------------------------ process value field -----------------------------------
for label in labels: # loop over all requested divergencies for datatype,labels in active.items(): # loop over vector,tensor
for label in labels: # loop over all requested divergencies
for accuracy in options.accuracy: for accuracy in options.accuracy:
if accuracy == 'FFT': if accuracy == 'FFT':
divergence[datatype][label][accuracy] = damask.core.math.divergenceFFT(dimension,values[datatype][label]) divergence[datatype][label][accuracy] = damask.core.math.divergenceFFT(dimension,values[datatype][label])
else: else:
divergence[datatype][label][accuracy] = damask.core.math.divergenceFDM(dimension,eval(accuracy)//2-1,values[datatype][label]) divergence[datatype][label][accuracy] = damask.core.math.divergenceFDM(dimension,eval(accuracy)//2-1,values[datatype][label])
# ------------------------------------------ process data ---------------------------------------
# ------------------------------------------ process data ---------------------------------------
table.data_rewind() table.data_rewind()
idx = 0 idx = 0
while table.data_read(): # read next data line of ASCII table outputAlive = True
(x,y,z) = location(idx,resolution) # figure out (x,y,z) position from line count while outputAlive and table.data_read(): # read next data line of ASCII table
(x,y,z) = damask.util.gridLocation(idx,resolution) # figure out (x,y,z) position from line count
idx += 1 idx += 1
for datatype,labels in active.items(): # loop over vector,tensor
for datatype,labels in active.items(): # loop over vector,tensor for label in labels: # loop over all requested
for label in labels: # loop over all requested
for accuracy in options.accuracy: for accuracy in options.accuracy:
table.data_append(list(divergence[datatype][label][accuracy][x,y,z].reshape(datainfo[datatype]['len']//3))) table.data_append(list(divergence[datatype][label][accuracy][x,y,z].reshape(datainfo[datatype]['len']//3)))
table.data_write() # output processed line outputAlive = table.data_write() # output processed line
# ------------------------------------------ output result --------------------------------------- # ------------------------------------------ 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)
file['input'].close() # close input ASCII table os.rename(file['name']+'_tmp',file['name']) # overwrite old one with tmp new
if file['name'] != 'STDIN':
file['output'].close # close output ASCII table
os.rename(file['name']+'_tmp',file['name']) # overwrite old one with tmp new