make table compare normalize data by type (scaler, vector, tensor)

lib/damask/test/test.py

@@ -5,6 +5,7 @@ import os,sys,shutil
 import logging,logging.config
 import damask
 import numpy as np
+import itertools
 from collections import Iterable
 from optparse import OptionParser
 
@@ -16,7 +17,7 @@ class Test():
   """
 
   variants = []
-  
+
   def __init__(self,description = ''):
 
     fh = logging.FileHandler('test.log')                                       # create file handler which logs even debug messages
@@ -90,11 +91,11 @@ class Test():
           logging.critical('\nWARNING:\n {}\n'.format(e))
           return variant+1                                                     # return culprit
       return 0
-  
+
   def feasible(self):
     """Check whether test is possible or not (e.g. no license available)."""
     return True
-    
+
   def clean(self):
     """Delete directory tree containing current results."""
     status = True
@@ -112,7 +113,7 @@ class Test():
       status = status and False
 
     return status
-    
+
   def prepareAll(self):
     """Do all necessary preparations for the whole test"""
     return True
@@ -120,7 +121,7 @@ class Test():
   def prepare(self,variant):
     """Do all necessary preparations for the run of each test variant"""
     return True
-  
+
 
   def run(self,variant):
     """Execute the requested test variant."""
@@ -152,17 +153,17 @@ class Test():
     """Directory containing current results of the test."""
     return os.path.normpath(os.path.join(self.dirBase,'current/'))
 
-  
+
   def dirProof(self):
     """Directory containing human readable proof of correctness for the test."""
     return os.path.normpath(os.path.join(self.dirBase,'proof/'))
 
-    
+
   def fileInRoot(self,dir,file):
     """Path to a file in the root directory of DAMASK."""
     return os.path.join(damask.Environment().rootDir(),dir,file)
 
-    
+
   def fileInReference(self,file):
     """Path to a file in the refrence directory for the test."""
     return os.path.join(self.dirReference(),file)
@@ -172,7 +173,7 @@ class Test():
     """Path to a file in the current results directory for the test."""
     return os.path.join(self.dirCurrent(),file)
 
-  
+
   def fileInProof(self,file):
     """Path to a file in the proof directory for the test."""
     return os.path.join(self.dirProof(),file)
@@ -189,58 +190,58 @@ class Test():
 
     for source,target in zip(map(mapA,A),map(mapB,B)):
       try:
-        shutil.copy2(source,target)  
+        shutil.copy2(source,target)
       except:
         logging.critical('error copying {} to {}'.format(source,target))
 
 
   def copy_Reference2Current(self,sourcefiles=[],targetfiles=[]):
-    
+
     if len(targetfiles) == 0: targetfiles = sourcefiles
     for i,file in enumerate(sourcefiles):
       try:
-        shutil.copy2(self.fileInReference(file),self.fileInCurrent(targetfiles[i]))  
+        shutil.copy2(self.fileInReference(file),self.fileInCurrent(targetfiles[i]))
       except:
         logging.critical('Reference2Current: Unable to copy file "{}"'.format(file))
 
- 
+
   def copy_Base2Current(self,sourceDir,sourcefiles=[],targetfiles=[]):
-    
+
     source=os.path.normpath(os.path.join(self.dirBase,'../../..',sourceDir))
     if len(targetfiles) == 0: targetfiles = sourcefiles
     for i,file in enumerate(sourcefiles):
       try:
-        shutil.copy2(os.path.join(source,file),self.fileInCurrent(targetfiles[i]))  
+        shutil.copy2(os.path.join(source,file),self.fileInCurrent(targetfiles[i]))
       except:
         logging.error(os.path.join(source,file))
         logging.critical('Base2Current: Unable to copy file "{}"'.format(file))
 
 
   def copy_Current2Reference(self,sourcefiles=[],targetfiles=[]):
-    
+
     if len(targetfiles) == 0: targetfiles = sourcefiles
     for i,file in enumerate(sourcefiles):
       try:
-        shutil.copy2(self.fileInCurrent(file),self.fileInReference(targetfiles[i]))  
+        shutil.copy2(self.fileInCurrent(file),self.fileInReference(targetfiles[i]))
       except:
         logging.critical('Current2Reference: Unable to copy file "{}"'.format(file))
 
-        
+
   def copy_Proof2Current(self,sourcefiles=[],targetfiles=[]):
-    
+
     if len(targetfiles) == 0: targetfiles = sourcefiles
     for i,file in enumerate(sourcefiles):
       try:
-        shutil.copy2(self.fileInProof(file),self.fileInCurrent(targetfiles[i]))  
+        shutil.copy2(self.fileInProof(file),self.fileInCurrent(targetfiles[i]))
       except:
         logging.critical('Proof2Current: Unable to copy file "{}"'.format(file))
 
-        
+
   def copy_Current2Current(self,sourcefiles=[],targetfiles=[]):
-    
+
     for i,file in enumerate(sourcefiles):
       try:
-        shutil.copy2(self.fileInReference(file),self.fileInCurrent(targetfiles[i]))  
+        shutil.copy2(self.fileInReference(file),self.fileInCurrent(targetfiles[i]))
       except:
         logging.critical('Current2Current: Unable to copy file "{}"'.format(file))
 
@@ -252,11 +253,11 @@ class Test():
 
     logging.info(error)
     logging.debug(out)
-    
-    return out,error
-    
 
-    
+    return out,error
+
+
+
   def compare_Array(self,File1,File2):
 
     import numpy as np
@@ -287,28 +288,28 @@ class Test():
 
 
   def compare_ArrayRefCur(self,ref,cur=''):
-    
+
     if cur =='': cur = ref
     refName = self.fileInReference(ref)
     curName = self.fileInCurrent(cur)
     return self.compare_Array(refName,curName)
 
-    
+
   def compare_ArrayCurCur(self,cur0,cur1):
-    
+
     cur0Name = self.fileInCurrent(cur0)
     cur1Name = self.fileInCurrent(cur1)
     return self.compare_Array(cur0Name,cur1Name)
 
   def compare_Table(self,headings0,file0,headings1,file1,normHeadings='',normType=None,
                                      absoluteTolerance=False,perLine=False,skipLines=[]):
-    
+
     import numpy as np
     logging.info('\n '.join(['comparing ASCII Tables',file0,file1]))
     if normHeadings == '': normHeadings = headings0
 
 # check if comparison is possible and determine lenght of columns
-    if len(headings0) == len(headings1) == len(normHeadings):                                         
+    if len(headings0) == len(headings1) == len(normHeadings):
       dataLength = len(headings0)
       length       = [1   for i in xrange(dataLength)]
       shape        = [[]  for i in xrange(dataLength)]
@@ -316,14 +317,14 @@ class Test():
       maxError     = [0.0 for i in xrange(dataLength)]
       absTol       = [absoluteTolerance for i in xrange(dataLength)]
       column       = [[1 for i in xrange(dataLength)] for j in xrange(2)]
- 
+
       norm         = [[]  for i in xrange(dataLength)]
       normLength   = [1   for i in xrange(dataLength)]
       normShape    = [[]  for i in xrange(dataLength)]
       normColumn   = [1   for i in xrange(dataLength)]
 
       for i in xrange(dataLength):
-        if headings0[i]['shape'] != headings1[i]['shape']: 
+        if headings0[i]['shape'] != headings1[i]['shape']:
           raise Exception('shape mismatch between {} and {} '.format(headings0[i]['label'],headings1[i]['label']))
         shape[i] = headings0[i]['shape']
         for j in xrange(np.shape(shape[i])[0]):
@@ -339,7 +340,7 @@ class Test():
     table0 = damask.ASCIItable(name=file0,readonly=True)
     table0.head_read()
     table1 = damask.ASCIItable(name=file1,readonly=True)
-    table1.head_read()   
+    table1.head_read()
 
     for i in xrange(dataLength):
       key0    = ('1_' if     length[i]>1 else '') +    headings0[i]['label']
@@ -355,7 +356,7 @@ class Test():
         column[0][i]  = table0.label_index(key0)
         column[1][i]  = table1.label_index(key1)
         normColumn[i] = table0.label_index(normKey)
-    
+
     line0 = 0
     while table0.data_read():                                                  # read next data line of ASCII table
       if line0 not in skipLines:
@@ -370,7 +371,7 @@ class Test():
           else:
             norm[i] = np.append(norm[i],np.linalg.norm(np.reshape(normData,normShape[i]),normType))
       line0 += 1
-    
+
     for i in xrange(dataLength):
       if not perLine: norm[i] = [np.max(norm[i]) for j in xrange(line0-len(skipLines))]
       data[i] = np.reshape(data[i],[line0-len(skipLines),length[i]])
@@ -441,14 +442,14 @@ class Test():
       logging.info(files[i]+':'+','.join(columns[i]))
 
     if len(files) < 2: return True                                             # single table is always close to itself...
-    
+
     data = []
     for table,labels in zip(tables,columns):
       table.data_readArray(labels)
       data.append(table.data)
       table.close()
-        
+
-    
+
     for i in xrange(1,len(data)):
       delta = data[i]-data[i-1]
       normBy = (np.abs(data[i]) + np.abs(data[i-1]))*0.5
@@ -457,7 +458,7 @@ class Test():
       std = np.amax(np.std(normedDelta,0))
       logging.info('mean: {:f}'.format(mean))
       logging.info('std: {:f}'.format(std))
-    
+
     return (mean<meanTol) & (std < stdTol)
 
 
@@ -467,17 +468,15 @@ class Test():
                      columns = [None],                                         # list of list of column labels (per file)
                      rtol = 1e-5,
                      atol = 1e-8,
-                     preFilter = -1.0,
-                     postFilter = -1.0,
                      debug = False):
     """
     compare tables with np.allclose
-
-    threshold can be used to ignore small values (a negative number disables this feature)
     """
     if not (isinstance(files, Iterable) and not isinstance(files, str)):       # check whether list of files is requested
       files = [str(files)]
 
+    if len(files) < 2: return True                                             # single table is always close to itself...
+
     tables = [damask.ASCIItable(name = filename,readonly = True) for filename in files]
     for table in tables:
       table.head_read()
@@ -486,7 +485,7 @@ class Test():
     columns = columns[:len(files)]                                             # truncate to same length as files
 
     for i,column in enumerate(columns):
-      if column is None: columns[i] = tables[i].labels(raw = True)             # if no column is given, read all
+      if column is None: columns[i] = tables[i].labels(raw = True)             # if no column is given, use all
 
     logging.info('comparing ASCIItables')
     for i in xrange(len(columns)):
@@ -496,44 +495,44 @@ class Test():
                  )
       logging.info(files[i]+':'+','.join(columns[i]))
 
-    if len(files) < 2: return True                                             # single table is always close to itself...
+    # peek into the ASCII table to figure out real table size
-    
+    # the cryptic table header does not share the same size as real
-    maximum = np.zeros(len(columns[0]),dtype='f')
+    # table
-    data = []
+    table.data_readArray(columns[0])
-    for table,labels in zip(tables,columns):
+    maximum = np.zeros(table.data.shape[1], dtype='f')
+    data = []  # list of feature table extracted from each file (ASCII table)
+    for table, labels in zip(tables, columns):
       table.data_readArray(labels)
-      data.append(np.where(np.abs(table.data)<preFilter,np.zeros_like(table.data),table.data))
+      for label in labels:
-      maximum += np.abs(table.data).max(axis=0)
+        idx = table.label_indexrange(label)
+        maximum[idx] = np.maximum(maximum[idx],
+                                  np.amax(np.linalg.norm(table.data[:,idx],axis=1)))
+      data.append(table.data)
       table.close()
-    
+
-    maximum /= len(tables)
+    maximum = np.where(maximum > 0.0, maximum, 1)                              # avoid div by zero for empty columns
-    maximum = np.where(maximum >0.0, maximum, 1)                               # avoid div by zero for empty columns
+
+
+    # normalize each table
     for i in xrange(len(data)):
       data[i] /= maximum
-    
-    mask = np.zeros_like(table.data,dtype='bool')
 
-    for table in data:
+    if debug:
-      mask |= np.where(np.abs(table)<postFilter,True,False)                    # mask out (all) tiny values
+      logging.debug(str(maximum))
-     
+      allclose = np.absolute(data[0]-data[1]) <= (atol + rtol*np.absolute(data[1]))
-    
+      for ok,valA,valB in zip(allclose,data[0],data[1]):
+        logging.debug('{}:\n {}\n{}\n'.format(ok,valA,valB))
+
     allclose = True                                                            # start optimistic
     for i in xrange(1,len(data)):
-      if debug:
+      allclose &= np.allclose(data[i-1],data[i],rtol,atol)                     # accumulate "pessimism"
-        t0 = np.where(mask,0.0,data[i-1])
-        t1 = np.where(mask,0.0,data[i  ])
-        j = np.argmin(np.abs(t1)*rtol+atol-np.abs(t0-t1))
-        logging.info('{:f}'.format(np.amax(np.abs(t0-t1)/(np.abs(t1)*rtol+atol))))
-        logging.info('{:f} {:f}'.format((t0*maximum).flatten()[j],(t1*maximum).flatten()[j]))
-      allclose &= np.allclose(np.where(mask,0.0,data[i-1]),
-                              np.where(mask,0.0,data[i  ]),rtol,atol)          # accumulate "pessimism"
 
     return allclose
 
-    
+
   def compare_TableRefCur(self,headingsRef,ref,headingsCur='',cur='',normHeadings='',normType=None,\
                                                  absoluteTolerance=False,perLine=False,skipLines=[]):
-    
+
     if cur == '': cur = ref
     if headingsCur == '': headingsCur = headingsRef
     refName = self.fileInReference(ref)
@@ -541,10 +540,10 @@ class Test():
     return self.compare_Table(headingsRef,refName,headingsCur,curName,normHeadings,normType,
                                                                absoluteTolerance,perLine,skipLines)
 
-    
+
   def compare_TableCurCur(self,headingsCur0,Cur0,Cur1,headingsCur1='',normHeadings='',normType=None,\
                                                  absoluteTolerance=False,perLine=False,skipLines=[]):
-    
+
     if headingsCur1 == '': headingsCur1 = headingsCur0
     cur0Name = self.fileInCurrent(Cur0)
     cur1Name = self.fileInCurrent(Cur1)
@@ -553,15 +552,17 @@ class Test():
 
 
   def report_Success(self,culprit):
-    
+
+    ret = culprit
+
     if culprit == 0:
-      logging.critical(('The test' if len(self.variants) == 1 else 'All {} tests'.format(len(self.variants))) + ' passed')
+      msg = 'The test passed' if len(self.variants) == 1 \
-      logging.critical('\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n')
+       else 'All {} tests passed.'.format(len(self.variants))
-      return 0
+    elif culprit == -1:
-    if culprit == -1:
+      msg = 'Warning: Could not start test...'
-      logging.warning('Warning: Could not start test')
+      ret = 0
-      return 0
     else:
-      logging.critical(' ********\n * Test {} failed...\n ********'.format(culprit))
+      msg = ' * Test "{}" failed.'.format(self.variants[culprit-1])
-      logging.critical('\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n')
+
-      return culprit
+    logging.critical('\n'.join(['*'*40,msg,'*'*40]) + '\n')
+    return ret