Merge remote-tracking branch 'origin/development' into less-public-variables

.gitlab-ci.yml

@@ -104,7 +104,7 @@ checkout:
     - release
 
 ###################################################################################################
-Pytest:
+Pytest_python:
   stage: python
   script:
     - cd $DAMASKROOT/python
@@ -385,6 +385,15 @@ Phenopowerlaw_singleSlip:
     - master
     - release
 
+Pytest_grid:
+  stage: grid
+  script:
+    - cd pytest
+    - pytest
+  except:
+    - master
+    - release
+
 ###################################################################################################
 Marc_compileIfort:
   stage: compileMarc

PRIVATE

@@ -1 +1 @@
-Subproject commit ec615d249d39e5d01446b01ab9a5b7e7601340ad
+Subproject commit 9573ce7bd2c1a7188c1aac5b83aa76d480c2bdb0

VERSION

@@ -1 +1 @@
-v2.0.3-1747-ga2e8e5b1
+v2.0.3-1808-g13c3ce00

examples/ConfigFiles/Phase_Phenopowerlaw_multiField.config

@@ -1,49 +0,0 @@
-[Aluminum]
-elasticity              hooke
-plasticity              phenopowerlaw
-
-(output)                resistance_slip
-(output)                shearrate_slip
-(output)                resolvedstress_slip
-(output)                accumulated_shear_slip
-(output)                resistance_twin
-(output)                shearrate_twin
-(output)                resolvedstress_twin
-(output)                accumulated_shear_twin
-
-lattice_structure       fcc
-Nslip                   12                # per family
-Ntwin                   0                # per family
-
-c11                     106.75e9
-c12                     60.41e9
-c44                     28.34e9
-
-gdot0_slip              0.001
-n_slip                  20
-tau0_slip               31e6                # per family
-tausat_slip             63e6                # per family
-a_slip                  2.25
-gdot0_twin              0.001
-n_twin                  20
-tau0_twin               31e6                # per family
-h0_slipslip             75e6
-interaction_slipslip    1 1 1.4 1.4 1.4 1.4
-atol_resistance         1
-
-(stiffness_degradation) damage
-(stiffness_degradation) porosity
-{./Phase_Damage.config}
-{./Phase_Thermal.config}
-{./Phase_Vacancy.config}
-{./Phase_Porosity.config}
-{./Phase_Hydrogen.config}
-{./Source_Damage_IsoBrittle.config}
-{./Source_Thermal_Dissipation.config}
-{./Source_Vacancy_PhenoPlasticity.config}
-{./Source_Vacancy_Irradiation.config}
-{./Kinematics_Thermal_Expansion.config}
-{./Kinematics_Vacancy_Strain.config}
-{./Kinematics_Hydrogen_Strain.config}
-
-

processing/post/addCauchy.py

@@ -42,8 +42,8 @@ for name in filenames:
 
     table = damask.Table.from_ASCII(StringIO(''.join(sys.stdin.read())) if name is None else name)
     table.add('Cauchy',
-              damask.mechanics.Cauchy(table.get(options.defgrad).reshape(-1,3,3),
+              damask.mechanics.Cauchy(table.get(options.stress ).reshape(-1,3,3),
-                                      table.get(options.stress ).reshape(-1,3,3)).reshape(-1,9),
+                                      table.get(options.defgrad).reshape(-1,3,3)).reshape(-1,9),
               scriptID+' '+' '.join(sys.argv[1:]))
 
     table.to_ASCII(sys.stdout if name is None else name)

processing/post/addPK2.py

@@ -43,8 +43,8 @@ for name in filenames:
     table = damask.Table.from_ASCII(StringIO(''.join(sys.stdin.read())) if name is None else name)
 
     table.add('S',
-              damask.mechanics.PK2(table.get(options.defgrad).reshape(-1,3,3),
+              damask.mechanics.PK2(table.get(options.stress ).reshape(-1,3,3),
-                                   table.get(options.stress ).reshape(-1,3,3)).reshape(-1,9),
+                                   table.get(options.defgrad).reshape(-1,3,3)).reshape(-1,9),
               scriptID+' '+' '.join(sys.argv[1:]))
 
     table.to_ASCII(sys.stdout if name is None else name)

processing/post/addSpectralDecomposition.py

@@ -2,6 +2,7 @@
 
 import os
 import sys
+from io import StringIO
 from optparse import OptionParser
 
 import numpy as np
@@ -33,69 +34,27 @@ parser.add_option('--no-check',
 
 parser.set_defaults(rh = True,
                     )
+
 (options,filenames) = parser.parse_args()
-
-if options.tensor is None:
-  parser.error('no data column specified.')
-
-# --- loop over input files -------------------------------------------------------------------------
-
 if filenames == []: filenames = [None]
 
 for name in filenames:
-  try:
-    table = damask.ASCIItable(name = name,
-                              buffered = False)
-  except: continue
     damask.util.report(scriptName,name)
 
-# ------------------------------------------ read header ------------------------------------------
+    table = damask.Table.from_ASCII(StringIO(''.join(sys.stdin.read())) if name is None else name)
 
-  table.head_read()
+    for tensor in options.tensor:
 
+        t = table.get(tensor).reshape(-1,3,3)
+        (u,v) = np.linalg.eigh(damask.mechanics.symmetric(t))
+        if options.rh: v[np.linalg.det(v) < 0.0,:,2] *= -1.0
 
-# ------------------------------------------ assemble header 1 ------------------------------------
+        for i,o in enumerate(['Min','Mid','Max']):
+            table.add('eigval{}({})'.format(o,tensor),u[:,i],
+                      scriptID+' '+' '.join(sys.argv[1:]))
 
-  items = {
+        for i,o in enumerate(['Min','Mid','Max']):
-            'tensor': {'dim': 9, 'shape': [3,3], 'labels':options.tensor, 'column': []},
+            table.add('eigvec{}({})'.format(o,tensor),v[:,:,i],
-          }
+                      scriptID+' '+' '.join(sys.argv[1:]))
-  errors  = []
-  remarks = []
         
-  for type, data in items.items():
+    table.to_ASCII(sys.stdout if name is None else name)
-    for what in data['labels']:
-      dim = table.label_dimension(what)
-      if dim != data['dim']: remarks.append('column {} is not a {}...'.format(what,type))
-      else:
-        items[type]['column'].append(table.label_index(what))
-        for order in ['Min','Mid','Max']:
-          table.labels_append(['eigval{}({})'.format(order,what)])                                         # extend ASCII header with new labels
-        for order in ['Min','Mid','Max']:
-          table.labels_append(['{}_eigvec{}({})'.format(i+1,order,what) for i in range(3)])                # extend ASCII header with new labels
-
-  if remarks != []: damask.util.croak(remarks)
-  if errors  != []:
-    damask.util.croak(errors)
-    table.close(dismiss = True)
-    continue
-
-# ------------------------------------------ assemble header 2 ------------------------------------
-
-  table.info_append(scriptID + '\t' + ' '.join(sys.argv[1:]))
-  table.head_write()
-
-# ------------------------------------------ process data -----------------------------------------
-
-  outputAlive = True
-  while outputAlive and table.data_read():                                                          # read next data line of ASCII table
-    for type, data in items.items():
-      for column in data['column']:
-        (u,v) = np.linalg.eigh(np.array(list(map(float,table.data[column:column+data['dim']]))).reshape(data['shape']))
-        if options.rh and np.dot(np.cross(v[:,0], v[:,1]), v[:,2]) < 0.0 : v[:, 2] *= -1.0          # ensure right-handed eigenvector basis
-        table.data_append(list(u))                                                                  # vector of max,mid,min eigval
-        table.data_append(list(v.transpose().reshape(data['dim'])))                                 # 3x3=9 combo vector of max,mid,min eigvec coordinates
-    outputAlive = table.data_write()                                                                # output processed line in accordance with column labeling
-
-# ------------------------------------------ output finalization -----------------------------------
-
-  table.close()                                                                                     # close input ASCII table (works for stdin)

processing/post/permuteData.py

@@ -83,7 +83,7 @@ for name in filenames:
        
 # ------------------------------------------ assemble header ---------------------------------------
 
-  randomSeed = int(os.urandom(4).encode('hex'), 16) if options.randomSeed is None else options.randomSeed         # random seed per file
+  randomSeed = int(os.urandom(4).hex(), 16) if options.randomSeed is None else options.randomSeed   # random seed per file
   np.random.seed(randomSeed)
 
   table.info_append([scriptID + '\t' + ' '.join(sys.argv[1:]),

processing/pre/seeds_fromDistribution.py

@@ -1,11 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: UTF-8 no BOM -*-
 
 import threading,time,os,sys,random
 import numpy as np
 from optparse import OptionParser
 from io import StringIO
-import binascii
 import damask
 
 scriptName = os.path.splitext(os.path.basename(__file__))[0]
@@ -16,9 +14,10 @@ currentSeedsName = None
 
 #---------------------------------------------------------------------------------------------------
 class myThread (threading.Thread):
-  """perturbes seed in seed file, performes Voronoi tessellation, evaluates, and updates best match"""
+  """Perturb seed in seed file, performes Voronoi tessellation, evaluates, and updates best match."""
 
   def __init__(self, threadID):
+    """Threading class with thread ID."""
     threading.Thread.__init__(self)
     self.threadID = threadID
 
@@ -215,7 +214,7 @@ options = parser.parse_args()[0]
 damask.util.report(scriptName,options.seedFile)
 
 if options.randomSeed is None:
-  options.randomSeed = int(binascii.hexlify(os.urandom(4)),16)
+  options.randomSeed = int(os.urandom(4).hex(),16)
 damask.util.croak(options.randomSeed)
 delta = (options.scale/options.grid[0],options.scale/options.grid[1],options.scale/options.grid[2])
 baseFile=os.path.splitext(os.path.basename(options.seedFile))[0]

python/damask/__init__.py

@@ -15,6 +15,7 @@ from .config      import Material         # noqa
 from .colormaps   import Colormap, Color  # noqa
 from .orientation import Symmetry, Lattice, Rotation, Orientation # noqa
 from .dadf5       import DADF5            # noqa
+from .dadf5       import DADF5 as Result  # noqa
 
 from .geom        import Geom             # noqa
 from .solver      import Solver           # noqa

python/damask/environment.py

@@ -8,7 +8,7 @@ class Environment():
     def __init__(self):
         """Read and provide values of DAMASK configuration."""
         self.options = {}
-        self.get_options()
+        self.__get_options()
 
     def relPath(self,relative = '.'):
         return os.path.join(self.rootDir(),relative)
@@ -16,7 +16,7 @@ class Environment():
     def rootDir(self):
         return os.path.normpath(os.path.join(os.path.realpath(__file__),'../../../'))
 
-    def get_options(self):
+    def __get_options(self):
         for item in ['DAMASK_NUM_THREADS',
                      'MSC_ROOT',
                      'MARC_VERSION',

python/damask/mechanics.py

@@ -1,8 +1,8 @@
 import numpy as np
 
-def Cauchy(F,P):
+def Cauchy(P,F):
     """
-    Return Cauchy stress calculated from 1. Piola-Kirchhoff stress and deformation gradient.
+    Return Cauchy stress calculated from first Piola-Kirchhoff stress and deformation gradient.
 
     Resulting tensor is symmetrized as the Cauchy stress needs to be symmetric.
 
@@ -21,23 +21,179 @@ def Cauchy(F,P):
     return symmetric(sigma)
 
 
-def PK2(F,P):
+def deviatoric_part(x):
     """
-    Return 2. Piola-Kirchhoff stress calculated from 1. Piola-Kirchhoff stress and deformation gradient.
+    Return deviatoric part of a tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Tensor of which the deviatoric part is computed.
+
+    """
+    return x - np.eye(3)*spherical_part(x) if np.shape(x) == (3,3) else \
+           x - np.einsum('ijk,i->ijk',np.broadcast_to(np.eye(3),[x.shape[0],3,3]),spherical_part(x))
+
+
+def eigenvalues(x):
+    """
+    Return the eigenvalues, i.e. principal components, of a symmetric tensor.
+
+    The eigenvalues are sorted in ascending order, each repeated according to
+    its multiplicity.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Symmetric tensor of which the eigenvalues are computed.
+
+    """
+    return np.linalg.eigvalsh(symmetric(x))
+
+
+def eigenvectors(x,RHS=False):
+    """
+    Return eigenvectors of a symmetric tensor.
+
+    The eigenvalues are sorted in ascending order of their associated eigenvalues.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Symmetric tensor of which the eigenvectors are computed.
+    RHS: bool, optional
+      Enforce right-handed coordinate system. Default is False.
+
+    """
+    (u,v) = np.linalg.eigh(symmetric(x))
+
+    if RHS:
+        if np.shape(x) == (3,3):
+            if np.linalg.det(v) < 0.0: v[:,2] *= -1.0
+        else:
+            v[np.linalg.det(v) < 0.0,:,2] *= -1.0
+    return v
+
+
+def left_stretch(x):
+    """
+    Return the left stretch of a tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Tensor of which the left stretch is computed.
+
+    """
+    return __polar_decomposition(x,'V')[0]
+
+
+def maximum_shear(x):
+    """
+    Return the maximum shear component of a symmetric tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Symmetric tensor of which the maximum shear is computed.
+
+    """
+    w = eigenvalues(x)
+    return (w[0] - w[2])*0.5 if np.shape(x) == (3,3) else \
+           (w[:,0] - w[:,2])*0.5
+
+
+def Mises_strain(epsilon):
+    """
+    Return the Mises equivalent of a strain tensor.
+
+    Parameters
+    ----------
+    epsilon : numpy.array of shape (:,3,3) or (3,3)
+      Symmetric strain tensor of which the von Mises equivalent is computed.
+
+    """
+    return __Mises(epsilon,2.0/3.0)
+
+
+def Mises_stress(sigma):
+    """
+    Return the Mises equivalent of a stress tensor.
+
+    Parameters
+    ----------
+    sigma : numpy.array of shape (:,3,3) or (3,3)
+      Symmetric stress tensor of which the von Mises equivalent is computed.
+
+    """
+    return __Mises(sigma,3.0/2.0)
+
+
+def PK2(P,F):
+    """
+    Calculate second Piola-Kirchhoff stress from first Piola-Kirchhoff stress and deformation gradient.
 
     Parameters
     ----------
-    F : numpy.array of shape (:,3,3) or (3,3)
-      Deformation gradient.
     P : numpy.array of shape (:,3,3) or (3,3)
       1. Piola-Kirchhoff stress.
+    F : numpy.array of shape (:,3,3) or (3,3)
+      Deformation gradient.
 
     """
     if np.shape(F) == np.shape(P) == (3,3):
         S = np.dot(np.linalg.inv(F),P)
     else:
         S = np.einsum('ijk,ikl->ijl',np.linalg.inv(F),P)
-    return S
+    return symmetric(S)
+
+def right_stretch(x):
+    """
+    Return the right stretch of a tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Tensor of which the right stretch is computed.
+
+    """
+    return __polar_decomposition(x,'U')[0]
+
+
+def rotational_part(x):
+    """
+    Return the rotational part of a tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Tensor of which the rotational part is computed.
+
+    """
+    return __polar_decomposition(x,'R')[0]
+
+
+def spherical_part(x,tensor=False):
+    """
+    Return spherical (hydrostatic) part of a tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Tensor of which the hydrostatic part is computed.
+    tensor : bool, optional
+      Map spherical part onto identity tensor. Default is false
+
+    """
+    if x.shape == (3,3):
+        sph = np.trace(x)/3.0
+        return sph if not tensor else np.eye(3)*sph
+    else:
+        sph = np.trace(x,axis1=1,axis2=2)/3.0
+        if not tensor:
+            return sph
+        else:
+            return np.einsum('ijk,i->ijk',np.broadcast_to(np.eye(3),(x.shape[0],3,3)),sph)
 
 
 def strain_tensor(F,t,m):
@@ -78,73 +234,6 @@ def strain_tensor(F,t,m):
            eps
 
 
-def deviatoric_part(x):
-    """
-    Return deviatoric part of a tensor.
-      
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Tensor of which the deviatoric part is computed.
-
-    """
-    return x - np.eye(3)*spherical_part(x) if np.shape(x) == (3,3) else \
-           x - np.einsum('ijk,i->ijk',np.broadcast_to(np.eye(3),[x.shape[0],3,3]),spherical_part(x)) 
-
-
-def spherical_part(x,tensor=False):
-    """
-    Return spherical (hydrostatic) part of a tensor.
-    
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Tensor of which the hydrostatic part is computed.
-    tensor : bool, optional
-      Map spherical part onto identity tensor. Default is false
-
-    """
-    if x.shape == (3,3):
-        sph = np.trace(x)/3.0
-        return sph if not tensor else np.eye(3)*sph
-    else:
-        sph = np.trace(x,axis1=1,axis2=2)/3.0
-        if not tensor:
-            return sph
-        else:
-            return np.einsum('ijk,i->ijk',np.broadcast_to(np.eye(3),(x.shape[0],3,3)),sph)
-    
-    
-def Mises_stress(sigma):
-    """
-    Return the Mises equivalent of a stress tensor.
-    
-    Parameters
-    ----------
-    sigma : numpy.array of shape (:,3,3) or (3,3)
-      Symmetric stress tensor of which the von Mises equivalent is computed.
-
-    """
-    s = deviatoric_part(sigma)
-    return np.sqrt(3.0/2.0*(np.sum(s**2.0))) if np.shape(sigma) == (3,3) else \
-           np.sqrt(3.0/2.0*np.einsum('ijk->i',s**2.0))
-    
-    
-def Mises_strain(epsilon):
-    """
-    Return the Mises equivalent of a strain tensor.
-    
-    Parameters
-    ----------
-    epsilon : numpy.array of shape (:,3,3) or (3,3)
-      Symmetric strain tensor of which the von Mises equivalent is computed.
-
-    """
-    s = deviatoric_part(epsilon)
-    return np.sqrt(2.0/3.0*(np.sum(s**2.0))) if np.shape(epsilon) == (3,3) else \
-           np.sqrt(2.0/3.0*np.einsum('ijk->i',s**2.0))
-
-
 def symmetric(x):
     """
     Return the symmetrized tensor.
@@ -158,39 +247,6 @@ def symmetric(x):
     return (x+transpose(x))*0.5
 
 
-def maximum_shear(x):
-    """
-    Return the maximum shear component of a symmetric tensor.
-    
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Symmetric tensor of which the maximum shear is computed.
-
-    """
-    w = np.linalg.eigvalsh(symmetric(x))                                                            # eigenvalues in ascending order
-    return (w[2] - w[0])*0.5 if np.shape(x) == (3,3) else \
-           (w[:,2] - w[:,0])*0.5
-    
-    
-def principal_components(x):
-    """
-    Return the principal components of a symmetric tensor.
-    
-    The principal components (eigenvalues) are sorted in descending order, each repeated according to
-    its multiplicity.
-    
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Symmetric tensor of which the principal compontents are computed.
-
-    """
-    w = np.linalg.eigvalsh(symmetric(x))                                                            # eigenvalues in ascending order
-    return w[::-1] if np.shape(x) == (3,3) else \
-           w[:,::-1]
-    
-    
 def transpose(x):
     """
     Return the transpose of a tensor.
@@ -205,45 +261,6 @@ def transpose(x):
            np.transpose(x,(0,2,1))
 
 
-def rotational_part(x):
-    """
-    Return the rotational part of a tensor.
-      
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Tensor of which the rotational part is computed.
-
-    """
-    return __polar_decomposition(x,'R')[0]
-
-
-def left_stretch(x):
-    """
-    Return the left stretch of a tensor.
-      
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Tensor of which the left stretch is computed.
-
-    """
-    return __polar_decomposition(x,'V')[0]
-  
-  
-def right_stretch(x):
-    """
-    Return the right stretch of a tensor.
-      
-    Parameters
-    ----------
-    x : numpy.array of shape (:,3,3) or (3,3)
-      Tensor of which the right stretch is computed.
-
-    """
-    return __polar_decomposition(x,'U')[0]
-
-
 def __polar_decomposition(x,requested):
     """
     Singular value decomposition.
@@ -270,3 +287,20 @@ def __polar_decomposition(x,requested):
         output.append(np.dot(R.T,x) if np.shape(x) == (3,3) else np.einsum('ikj,ikl->ijl',R,x))
 
     return tuple(output)
+
+
+def __Mises(x,s):
+    """
+    Base equation for Mises equivalent of a stres or strain tensor.
+
+    Parameters
+    ----------
+    x : numpy.array of shape (:,3,3) or (3,3)
+      Symmetric tensor of which the von Mises equivalent is computed.
+    s : float
+      Scaling factor (2/3 for strain, 3/2 for stress).
+    
+    """
+    d = deviatoric_part(x)
+    return np.sqrt(s*(np.sum(d**2.0))) if np.shape(x) == (3,3) else \
+           np.sqrt(s*np.einsum('ijk->i',d**2.0))

python/damask/util.py

@@ -3,9 +3,11 @@ import time
 import os
 import subprocess
 import shlex
+from fractions import Fraction
+from functools import reduce
 from optparse import Option
-from queue import Queue
+
-from threading import Thread
+import numpy as np
 
 class bcolors:
     """
@@ -161,6 +163,24 @@ def progressBar(iteration, total, prefix='', bar_length=50):
   sys.stderr.flush()
 
 
+def scale_to_coprime(v):
+  """Scale vector to co-prime (relatively prime) integers."""
+  MAX_DENOMINATOR = 1000
+
+  def get_square_denominator(x):
+    """Denominator of the square of a number."""
+    return Fraction(x ** 2).limit_denominator(MAX_DENOMINATOR).denominator
+
+  def lcm(a, b):
+    """Least common multiple."""
+    return a * b // np.gcd(a, b)
+
+  denominators = [int(get_square_denominator(i)) for i in v]
+  s = reduce(lcm, denominators) ** 0.5
+  m = (np.array(v)*s).astype(np.int)
+  return m//reduce(np.gcd,m)
+
+
 class return_message():
   """Object with formatted return message."""
 
@@ -179,57 +199,3 @@ class return_message():
   def __repr__(self):
     """Return message suitable for interactive shells."""
     return srepr(self.message)
-
-
-class ThreadPool:
-  """Pool of threads consuming tasks from a queue."""
-
-  class Worker(Thread):
-    """Thread executing tasks from a given tasks queue."""
-
-    def __init__(self, tasks):
-      """Worker for tasks."""
-      Thread.__init__(self)
-      self.tasks = tasks
-      self.daemon = True
-      self.start()
-
-    def run(self):
-      while True:
-        func, args, kargs = self.tasks.get()
-        try:
-          func(*args, **kargs)
-        except Exception as e:
-          # An exception happened in this thread
-          print(e)
-        finally:
-          # Mark this task as done, whether an exception happened or not
-          self.tasks.task_done()
-
-
-  def __init__(self, num_threads):
-    """
-    Thread pool.
-
-    Parameters
-    ----------
-    num_threads : int
-      number of threads
-
-    """
-    self.tasks = Queue(num_threads)
-    for _ in range(num_threads):
-      self.Worker(self.tasks)
-
-  def add_task(self, func, *args, **kargs):
-    """Add a task to the queue."""
-    self.tasks.put((func, args, kargs))
-
-  def map(self, func, args_list):
-    """Add a list of tasks to the queue."""
-    for args in args_list:
-      self.add_task(func, args)
-
-  def wait_completion(self):
-    """Wait for completion of all the tasks in the queue."""
-    self.tasks.join()

python/tests/test_DADF5.py

@@ -40,7 +40,7 @@ class TestDADF5:
         assert np.allclose(in_memory,in_file)
 
     def test_add_calculation(self,default):
-        default.add_calculation('2.0*np.abs(#F#)-1.0','x','-','test')
+        default.add_calculation('x','2.0*np.abs(#F#)-1.0','-','my notes')
         loc = {'F':    default.get_dataset_location('F'),
                'x':    default.get_dataset_location('x')}
         in_memory = 2.0*np.abs(default.read_dataset(loc['F'],0))-1.0
@@ -52,8 +52,8 @@ class TestDADF5:
         loc = {'F':    default.get_dataset_location('F'),
                'P':    default.get_dataset_location('P'),
                'sigma':default.get_dataset_location('sigma')}
-        in_memory = mechanics.Cauchy(default.read_dataset(loc['F'],0),
+        in_memory = mechanics.Cauchy(default.read_dataset(loc['P'],0),
-                                     default.read_dataset(loc['P'],0))
+                                     default.read_dataset(loc['F'],0))
         in_file   = default.read_dataset(loc['sigma'],0)
         assert np.allclose(in_memory,in_file)
 
@@ -73,6 +73,54 @@ class TestDADF5:
         in_file   = default.read_dataset(loc['s_P'],0)
         assert np.allclose(in_memory,in_file)
 
+    def test_add_eigenvalues(self,default):
+        default.add_Cauchy('P','F')
+        default.add_eigenvalues('sigma')
+        loc = {'sigma'        :default.get_dataset_location('sigma'),
+               'lambda(sigma)':default.get_dataset_location('lambda(sigma)')}
+        in_memory = mechanics.eigenvalues(default.read_dataset(loc['sigma'],0))
+        in_file   = default.read_dataset(loc['lambda(sigma)'],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_eigenvectors(self,default):
+        default.add_Cauchy('P','F')
+        default.add_eigenvectors('sigma')
+        loc = {'sigma'   :default.get_dataset_location('sigma'),
+               'v(sigma)':default.get_dataset_location('v(sigma)')}
+        in_memory = mechanics.eigenvectors(default.read_dataset(loc['sigma'],0))
+        in_file   = default.read_dataset(loc['v(sigma)'],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_maximum_shear(self,default):
+        default.add_Cauchy('P','F')
+        default.add_maximum_shear('sigma')
+        loc = {'sigma'           :default.get_dataset_location('sigma'),
+               'max_shear(sigma)':default.get_dataset_location('max_shear(sigma)')}
+        in_memory = mechanics.maximum_shear(default.read_dataset(loc['sigma'],0)).reshape(-1,1)
+        in_file   = default.read_dataset(loc['max_shear(sigma)'],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_Mises_strain(self,default):
+        t = ['V','U'][np.random.randint(0,2)]
+        m = np.random.random()*2.0 - 1.0
+        default.add_strain_tensor('F',t,m)
+        label = 'epsilon_{}^{}(F)'.format(t,m)
+        default.add_Mises(label)
+        loc = {label      :default.get_dataset_location(label),
+               label+'_vM':default.get_dataset_location(label+'_vM')}
+        in_memory = mechanics.Mises_strain(default.read_dataset(loc[label],0)).reshape(-1,1)
+        in_file   = default.read_dataset(loc[label+'_vM'],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_Mises_stress(self,default):
+        default.add_Cauchy('P','F')
+        default.add_Mises('sigma')
+        loc = {'sigma'   :default.get_dataset_location('sigma'),
+               'sigma_vM':default.get_dataset_location('sigma_vM')}
+        in_memory = mechanics.Mises_stress(default.read_dataset(loc['sigma'],0)).reshape(-1,1)
+        in_file   = default.read_dataset(loc['sigma_vM'],0)
+        assert np.allclose(in_memory,in_file)
+
     def test_add_norm(self,default):
         default.add_norm('F',1)
         loc = {'F':    default.get_dataset_location('F'),
@@ -81,6 +129,24 @@ class TestDADF5:
         in_file   = default.read_dataset(loc['|F|_1'],0)
         assert np.allclose(in_memory,in_file)
 
+    def test_add_PK2(self,default):
+        default.add_PK2('P','F')
+        loc = {'F':default.get_dataset_location('F'),
+               'P':default.get_dataset_location('P'),
+               'S':default.get_dataset_location('S')}
+        in_memory = mechanics.PK2(default.read_dataset(loc['P'],0),
+                                  default.read_dataset(loc['F'],0))
+        in_file   = default.read_dataset(loc['S'],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_rotational_part(self,default):
+        default.add_rotational_part('F')
+        loc = {'F':    default.get_dataset_location('F'),
+               'R(F)': default.get_dataset_location('R(F)')}
+        in_memory = mechanics.rotational_part(default.read_dataset(loc['F'],0))
+        in_file   = default.read_dataset(loc['R(F)'],0)
+        assert np.allclose(in_memory,in_file)
+
     def test_add_spherical(self,default):
         default.add_spherical('P')
         loc = {'P':   default.get_dataset_location('P'),
@@ -88,3 +154,30 @@ class TestDADF5:
         in_memory = mechanics.spherical_part(default.read_dataset(loc['P'],0)).reshape(-1,1)
         in_file   = default.read_dataset(loc['p_P'],0)
         assert np.allclose(in_memory,in_file)
+
+    def test_add_strain(self,default):
+        t = ['V','U'][np.random.randint(0,2)]
+        m = np.random.random()*2.0 - 1.0
+        default.add_strain_tensor('F',t,m)
+        label = 'epsilon_{}^{}(F)'.format(t,m)
+        loc = {'F':   default.get_dataset_location('F'),
+               label: default.get_dataset_location(label)}
+        in_memory = mechanics.strain_tensor(default.read_dataset(loc['F'],0),t,m)
+        in_file   = default.read_dataset(loc[label],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_stretch_right(self,default):
+        default.add_stretch_tensor('F','U')
+        loc = {'F':    default.get_dataset_location('F'),
+               'U(F)': default.get_dataset_location('U(F)')}
+        in_memory = mechanics.right_stretch(default.read_dataset(loc['F'],0))
+        in_file   = default.read_dataset(loc['U(F)'],0)
+        assert np.allclose(in_memory,in_file)
+
+    def test_add_stretch_left(self,default):
+        default.add_stretch_tensor('F','V')
+        loc = {'F':    default.get_dataset_location('F'),
+               'V(F)': default.get_dataset_location('V(F)')}
+        in_memory = mechanics.left_stretch(default.read_dataset(loc['F'],0))
+        in_file   = default.read_dataset(loc['V(F)'],0)
+        assert np.allclose(in_memory,in_file)

python/tests/test_mechanics.py

@@ -10,9 +10,64 @@ class TestMechanics:
     def test_vectorize_Cauchy(self):
         P = np.random.random((self.n,3,3))
         F = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.Cauchy(F,P)[self.c],
+        assert np.allclose(mechanics.Cauchy(P,F)[self.c],
-                            mechanics.Cauchy(F[self.c],P[self.c]))
+                           mechanics.Cauchy(P[self.c],F[self.c]))
 
+    def test_vectorize_deviatoric_part(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.deviatoric_part(x)[self.c],
+                           mechanics.deviatoric_part(x[self.c]))
+
+    def test_vectorize_eigenvalues(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.eigenvalues(x)[self.c],
+                           mechanics.eigenvalues(x[self.c]))
+
+    def test_vectorize_eigenvectors(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.eigenvectors(x)[self.c],
+                           mechanics.eigenvectors(x[self.c]))
+
+    def test_vectorize_left_stretch(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.left_stretch(x)[self.c],
+                           mechanics.left_stretch(x[self.c]))
+
+    def test_vectorize_maximum_shear(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.maximum_shear(x)[self.c],
+                           mechanics.maximum_shear(x[self.c]))
+
+    def test_vectorize_Mises_strain(self):
+        epsilon = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.Mises_strain(epsilon)[self.c],
+                           mechanics.Mises_strain(epsilon[self.c]))
+
+    def test_vectorize_Mises_stress(self):
+        sigma = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.Mises_stress(sigma)[self.c],
+                           mechanics.Mises_stress(sigma[self.c]))
+
+    def test_vectorize_PK2(self):
+        F = np.random.random((self.n,3,3))
+        P = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.PK2(P,F)[self.c],
+                           mechanics.PK2(P[self.c],F[self.c]))
+
+    def test_vectorize_right_stretch(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.right_stretch(x)[self.c],
+                           mechanics.right_stretch(x[self.c]))
+
+    def test_vectorize_rotational_part(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.rotational_part(x)[self.c],
+                           mechanics.rotational_part(x[self.c]))
+
+    def test_vectorize_spherical_part(self):
+        x = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.spherical_part(x,True)[self.c],
+                           mechanics.spherical_part(x[self.c],True))
 
     def test_vectorize_strain_tensor(self):
         F = np.random.random((self.n,3,3))
@@ -21,79 +76,24 @@ class TestMechanics:
         assert np.allclose(mechanics.strain_tensor(F,t,m)[self.c],
                            mechanics.strain_tensor(F[self.c],t,m))
 
-
-    def test_vectorize_deviatoric_part(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.deviatoric_part(x)[self.c],
-                            mechanics.deviatoric_part(x[self.c]))
-
-
-    def test_vectorize_spherical_part(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.spherical_part(x,True)[self.c],
-                            mechanics.spherical_part(x[self.c],True))
-
-
-    def test_vectorize_Mises_stress(self):
-         sigma = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.Mises_stress(sigma)[self.c],
-                            mechanics.Mises_stress(sigma[self.c]))
-
-
-    def test_vectorize_Mises_strain(self):
-         epsilon = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.Mises_strain(epsilon)[self.c],
-                            mechanics.Mises_strain(epsilon[self.c]))
-
-
     def test_vectorize_symmetric(self):
         x = np.random.random((self.n,3,3))
         assert np.allclose(mechanics.symmetric(x)[self.c],
                            mechanics.symmetric(x[self.c]))
 
-
-    def test_vectorize_maximum_shear(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.maximum_shear(x)[self.c],
-                            mechanics.maximum_shear(x[self.c]))
-
-
-    def test_vectorize_principal_components(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.principal_components(x)[self.c],
-                            mechanics.principal_components(x[self.c]))
-
-
     def test_vectorize_transpose(self):
         x = np.random.random((self.n,3,3))
         assert np.allclose(mechanics.transpose(x)[self.c],
                            mechanics.transpose(x[self.c]))
 
 
-    def test_vectorize_rotational_part(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.rotational_part(x)[self.c],
-                            mechanics.rotational_part(x[self.c]))
-
-
-    def test_vectorize_left_stretch(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.left_stretch(x)[self.c],
-                            mechanics.left_stretch(x[self.c]))
-
-
-    def test_vectorize_right_stretch(self):
-         x = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.right_stretch(x)[self.c],
-                            mechanics.right_stretch(x[self.c]))
-
-
     def test_Cauchy(self):
         """Ensure Cauchy stress is symmetrized 1. Piola-Kirchhoff stress for no deformation."""
         P = np.random.random((self.n,3,3))
-         assert np.allclose(mechanics.Cauchy(np.broadcast_to(np.eye(3),(self.n,3,3)),P),
+        assert np.allclose(mechanics.Cauchy(P,np.broadcast_to(np.eye(3),(self.n,3,3))),
                            mechanics.symmetric(P))
 
+
     def test_polar_decomposition(self):
         """F = RU = VR."""
         F = np.broadcast_to(np.eye(3),[self.n,3,3])*np.random.random((self.n,3,3))
@@ -104,6 +104,13 @@ class TestMechanics:
                            np.matmul(V,R))
 
 
+    def test_PK2(self):
+        """Ensure 2. Piola-Kirchhoff stress is symmetrized 1. Piola-Kirchhoff stress for no deformation."""
+        P = np.random.random((self.n,3,3))
+        assert np.allclose(mechanics.PK2(P,np.broadcast_to(np.eye(3),(self.n,3,3))),
+                           mechanics.symmetric(P))
+
+
     def test_strain_tensor_no_rotation(self):
         """Ensure that left and right stretch give same results for no rotation."""
         F = np.broadcast_to(np.eye(3),[self.n,3,3])*np.random.random((self.n,3,3))
@@ -186,3 +193,33 @@ class TestMechanics:
         x = np.random.random((self.n,3,3))
         assert np.allclose(mechanics.Mises_stress(x)/mechanics.Mises_strain(x),
                            1.5)
+
+
+    def test_eigenvalues(self):
+        """Ensure that the characteristic polynomial can be solved."""
+        A = mechanics.symmetric(np.random.random((self.n,3,3)))
+        lambd = mechanics.eigenvalues(A)
+        s = np.random.randint(self.n)
+        for i in range(3):
+           assert np.allclose(np.linalg.det(A[s]-lambd[s,i]*np.eye(3)),.0)
+
+    def test_eigenvalues_and_vectors(self):
+        """Ensure that eigenvalues and -vectors are the solution to the characteristic polynomial."""
+        A = mechanics.symmetric(np.random.random((self.n,3,3)))
+        lambd = mechanics.eigenvalues(A)
+        x     = mechanics.eigenvectors(A)
+        s = np.random.randint(self.n)
+        for i in range(3):
+           assert np.allclose(np.dot(A[s]-lambd[s,i]*np.eye(3),x[s,:,i]),.0)
+
+    def test_eigenvectors_RHS(self):
+        """Ensure that RHS coordinate system does only change sign of determinant."""
+        A = mechanics.symmetric(np.random.random((self.n,3,3)))
+        LRHS = np.linalg.det(mechanics.eigenvectors(A,RHS=False))
+        RHS  = np.linalg.det(mechanics.eigenvectors(A,RHS=True))
+        assert np.allclose(np.abs(LRHS),RHS)
+
+    def test_spherical_no_shear(self):
+        """Ensure that sherical stress has max shear of 0.0."""
+        A = mechanics.spherical_part(mechanics.symmetric(np.random.random((self.n,3,3))),True)
+        assert np.allclose(mechanics.maximum_shear(A),0.0)

src/IO.f90

@@ -400,6 +400,8 @@ subroutine IO_error(error_ID,el,ip,g,instance,ext_msg)
       msg = 'number of values does not match'
     case (147)
       msg = 'not supported anymore'
+    case (148)
+      msg = 'Nconstituents mismatch between homogenization and microstructure'
 
 !--------------------------------------------------------------------------------------------------
 ! material error messages and related messages in mesh

src/crystallite.f90

@@ -734,7 +734,7 @@ subroutine crystallite_results
     real(pReal), allocatable, dimension(:,:,:) :: select_tensors
     integer :: e,i,c,j
 
-    allocate(select_tensors(3,3,count(material_phaseAt==instance)*homogenization_maxNgrains*discretization_nIP))
+    allocate(select_tensors(3,3,count(material_phaseAt==instance)*discretization_nIP))
 
     j=0
     do e = 1, size(material_phaseAt,2)

src/grid/grid_mech_FEM.f90

@@ -475,7 +475,7 @@ subroutine formResidual(da_local,x_local, &
     write(6,'(1x,a,3(a,i0))') trim(incInfo), ' @ Iteration ', itmin, '≤',totalIter+1, '≤', itmax
     if (iand(debug_level(debug_spectral),debug_spectralRotation) /= 0) &
       write(6,'(/,a,/,3(3(f12.7,1x)/))',advance='no') &
-              ' deformation gradient aim (lab) =', transpose(params%rotation_BC%rotTensor2(F_aim,active=.true.))
+              ' deformation gradient aim (lab) =', transpose(params%rotation_BC%rotate(F_aim,active=.true.))
     write(6,'(/,a,/,3(3(f12.7,1x)/))',advance='no') &
               ' deformation gradient aim       =', transpose(F_aim)
     flush(6)
@@ -491,7 +491,7 @@ subroutine formResidual(da_local,x_local, &
       x_elem(ctr,1:3) = x_scal(0:2,i+ii,j+jj,k+kk)
     enddo; enddo; enddo
     ii = i-xstart+1; jj = j-ystart+1; kk = k-zstart+1
-    F(1:3,1:3,ii,jj,kk) = params%rotation_BC%rotTensor2(F_aim,active=.true.) + transpose(matmul(BMat,x_elem)) 
+    F(1:3,1:3,ii,jj,kk) = params%rotation_BC%rotate(F_aim,active=.true.) + transpose(matmul(BMat,x_elem))
   enddo; enddo; enddo
   call DMDAVecRestoreArrayF90(da_local,x_local,x_scal,ierr);CHKERRQ(ierr)
 

src/grid/grid_mech_spectral_basic.f90

@@ -297,7 +297,7 @@ subroutine grid_mech_spectral_basic_forward(cutBack,guess,timeinc,timeinc_old,lo
 
     Fdot = utilities_calculateRate(guess, &
                                    F_lastInc,reshape(F,[3,3,grid(1),grid(2),grid3]),timeinc_old, &
-                                   rotation_BC%rotTensor2(F_aimDot,active=.true.))
+                                   rotation_BC%rotate(F_aimDot,active=.true.))
     F_lastInc = reshape(F,[3,3,grid(1),grid(2),grid3])
 
     materialpoint_F0 = reshape(F, [3,3,1,product(grid(1:2))*grid3])
@@ -307,7 +307,7 @@ subroutine grid_mech_spectral_basic_forward(cutBack,guess,timeinc,timeinc_old,lo
 ! update average and local deformation gradients
   F_aim = F_aim_lastInc + F_aimDot * timeinc
   F = reshape(Utilities_forwardField(timeinc,F_lastInc,Fdot, &                                       ! estimate of F at end of time+timeinc that matches rotated F_aim on average
-              rotation_BC%rotTensor2(F_aim,active=.true.)),[9,grid(1),grid(2),grid3])
+              rotation_BC%rotate(F_aim,active=.true.)),[9,grid(1),grid(2),grid3])
   call DMDAVecRestoreArrayF90(da,solution_vec,F,ierr); CHKERRQ(ierr)
 
 end subroutine grid_mech_spectral_basic_forward
@@ -441,7 +441,7 @@ subroutine formResidual(in, F, &
     write(6,'(1x,a,3(a,i0))') trim(incInfo), ' @ Iteration ', itmin, '≤',totalIter, '≤', itmax
     if (iand(debug_level(debug_spectral),debug_spectralRotation) /= 0) &
       write(6,'(/,a,/,3(3(f12.7,1x)/))',advance='no') &
-              ' deformation gradient aim (lab) =', transpose(params%rotation_BC%rotTensor2(F_aim,active=.true.))
+              ' deformation gradient aim (lab) =', transpose(params%rotation_BC%rotate(F_aim,active=.true.))
     write(6,'(/,a,/,3(3(f12.7,1x)/))',advance='no') &
               ' deformation gradient aim       =', transpose(F_aim)
     flush(6)
@@ -466,7 +466,7 @@ subroutine formResidual(in, F, &
   tensorField_real(1:3,1:3,1:grid(1),1:grid(2),1:grid3) = residuum                                  ! store fPK field for subsequent FFT forward transform
   call utilities_FFTtensorForward                                                                   ! FFT forward of global "tensorField_real"
   err_div = Utilities_divergenceRMS()                                                               ! divRMS of tensorField_fourier for later use
-  call utilities_fourierGammaConvolution(params%rotation_BC%rotTensor2(deltaF_aim,active=.true.))   ! convolution of Gamma and tensorField_fourier
+  call utilities_fourierGammaConvolution(params%rotation_BC%rotate(deltaF_aim,active=.true.))       ! convolution of Gamma and tensorField_fourier
   call utilities_FFTtensorBackward                                                                  ! FFT backward of global tensorField_fourier
 
 !--------------------------------------------------------------------------------------------------

src/grid/grid_mech_spectral_polarisation.f90

@@ -321,10 +321,10 @@ subroutine grid_mech_spectral_polarisation_forward(cutBack,guess,timeinc,timeinc
 
     Fdot     = utilities_calculateRate(guess, &
                                        F_lastInc,reshape(F,[3,3,grid(1),grid(2),grid3]),timeinc_old, &
-                                       rotation_BC%rotTensor2(F_aimDot,active=.true.))
+                                       rotation_BC%rotate(F_aimDot,active=.true.))
     F_tauDot = utilities_calculateRate(guess, &
                                        F_tau_lastInc,reshape(F_tau,[3,3,grid(1),grid(2),grid3]), timeinc_old, &
-                                       rotation_BC%rotTensor2(F_aimDot,active=.true.))
+                                       rotation_BC%rotate(F_aimDot,active=.true.))
     F_lastInc     = reshape(F,    [3,3,grid(1),grid(2),grid3])
     F_tau_lastInc = reshape(F_tau,[3,3,grid(1),grid(2),grid3])
 
@@ -335,7 +335,7 @@ subroutine grid_mech_spectral_polarisation_forward(cutBack,guess,timeinc,timeinc
 ! update average and local deformation gradients
   F_aim = F_aim_lastInc + F_aimDot * timeinc
   F = reshape(utilities_forwardField(timeinc,F_lastInc,Fdot, &                                      ! estimate of F at end of time+timeinc that matches rotated F_aim on average
-                                     rotation_BC%rotTensor2(F_aim,active=.true.)),&
+                                     rotation_BC%rotate(F_aim,active=.true.)),&
               [9,grid(1),grid(2),grid3])
   if (guess) then
      F_tau = reshape(Utilities_forwardField(timeinc,F_tau_lastInc,F_taudot), &
@@ -510,7 +510,7 @@ subroutine formResidual(in, FandF_tau, &
     write(6,'(1x,a,3(a,i0))') trim(incInfo), ' @ Iteration ', itmin, '≤',totalIter, '≤', itmax
     if (iand(debug_level(debug_spectral),debug_spectralRotation) /= 0) &
       write(6,'(/,a,/,3(3(f12.7,1x)/))',advance='no') &
-              ' deformation gradient aim (lab) =', transpose(params%rotation_BC%rotTensor2(F_aim,active=.true.))
+              ' deformation gradient aim (lab) =', transpose(params%rotation_BC%rotate(F_aim,active=.true.))
     write(6,'(/,a,/,3(3(f12.7,1x)/))',advance='no') &
               ' deformation gradient aim       =', transpose(F_aim)
     flush(6)
@@ -529,7 +529,7 @@ subroutine formResidual(in, FandF_tau, &
 !--------------------------------------------------------------------------------------------------
 ! doing convolution in Fourier space
   call utilities_FFTtensorForward
-  call utilities_fourierGammaConvolution(params%rotation_BC%rotTensor2(polarBeta*F_aim,active=.true.)) 
+  call utilities_fourierGammaConvolution(params%rotation_BC%rotate(polarBeta*F_aim,active=.true.))
   call utilities_FFTtensorBackward
 
 !--------------------------------------------------------------------------------------------------
@@ -547,7 +547,7 @@ subroutine formResidual(in, FandF_tau, &
 ! stress BC handling
   F_aim = F_aim - math_mul3333xx33(S, ((P_av - params%stress_BC)))                                  ! S = 0.0 for no bc
   err_BC = maxval(abs((1.0_pReal-params%stress_mask) * math_mul3333xx33(C_scale,F_aim &
-                                                 -params%rotation_BC%rotTensor2(F_av)) + &
+                                                 -params%rotation_BC%rotate(F_av)) + &
                                  params%stress_mask  * (P_av-params%stress_BC)))                    ! mask = 0.0 for no bc
 ! calculate divergence
   tensorField_real = 0.0_pReal

src/grid/spectral_utilities.f90

@@ -688,9 +688,10 @@ function utilities_maskedCompliance(rot_BC,mask_stress,C)
   type(rotation), intent(in)                     :: rot_BC                                          !< rotation of load frame
   logical,        intent(in), dimension(3,3)     :: mask_stress                                     !< mask of stress BC
 
-  integer :: j, k, m, n
+  integer :: i, j
   logical, dimension(9)   :: mask_stressVector
-  real(pReal), dimension(9,9) :: temp99_Real
+  logical, dimension(9,9) :: mask
+  real(pReal), dimension(9,9) :: temp99_real
   integer :: size_reduced = 0
   real(pReal),              dimension(:,:), allocatable ::  &
     s_reduced, &                                                                                    !< reduced compliance matrix (depending on number of stress BC)
@@ -702,10 +703,7 @@ function utilities_maskedCompliance(rot_BC,mask_stress,C)
   mask_stressVector = reshape(transpose(mask_stress), [9])
   size_reduced = count(mask_stressVector)
   if(size_reduced > 0) then
-    allocate (c_reduced(size_reduced,size_reduced), source =0.0_pReal)
+    temp99_real = math_3333to99(rot_BC%rotate(C))
-    allocate (s_reduced(size_reduced,size_reduced), source =0.0_pReal)
-    allocate (sTimesC(size_reduced,size_reduced),   source =0.0_pReal)
-    temp99_Real = math_3333to99(rot_BC%rotTensor4(C))
 
     if(debugGeneral) then
       write(6,'(/,a)') ' ... updating masked compliance ............................................'
@@ -713,42 +711,21 @@ function utilities_maskedCompliance(rot_BC,mask_stress,C)
                                                    transpose(temp99_Real)*1.0e-9_pReal
       flush(6)
     endif
-    k = 0                                                                                           ! calculate reduced stiffness
-    do n = 1,9
-      if(mask_stressVector(n)) then
-        k = k + 1
-        j = 0
-        do m = 1,9
-          if(mask_stressVector(m)) then
-            j = j + 1
-            c_reduced(k,j) = temp99_Real(n,m)
-    endif; enddo; endif; enddo
 
+    do i = 1,9; do j = 1,9
+      mask(i,j) = mask_stressVector(i) .and. mask_stressVector(j)
+    enddo; enddo
+    c_reduced = reshape(pack(temp99_Real,mask),[size_reduced,size_reduced])
+
+    allocate(s_reduced,mold = c_reduced)
     call math_invert(s_reduced, errmatinv, c_reduced)                                               ! invert reduced stiffness
     if (any(IEEE_is_NaN(s_reduced))) errmatinv = .true.
     if (errmatinv) call IO_error(error_ID=400,ext_msg='utilities_maskedCompliance')
-    temp99_Real = 0.0_pReal                                                                         ! fill up compliance with zeros
-     k = 0
-     do n = 1,9
-       if(mask_stressVector(n)) then
-         k = k + 1
-         j = 0
-         do m = 1,9
-           if(mask_stressVector(m)) then
-             j = j + 1
-             temp99_Real(n,m) = s_reduced(k,j)
-    endif; enddo; endif; enddo
 
 !--------------------------------------------------------------------------------------------------
 ! check if inversion was successful
     sTimesC = matmul(c_reduced,s_reduced)
-    do m=1, size_reduced
+    errmatinv = errmatinv .or. any(dNeq(sTimesC,math_identity2nd(size_reduced),1.0e-12_pReal))
-      do n=1, size_reduced
-        errmatinv = errmatinv &
-               .or. (m==n .and. abs(sTimesC(m,n)-1.0_pReal) > 1.0e-12_pReal) &                      ! diagonal elements of S*C should be 1
-               .or. (m/=n .and. abs(sTimesC(m,n))           > 1.0e-12_pReal)                        ! off-diagonal elements of S*C should be 0
-      enddo
-    enddo
     if (debugGeneral .or. errmatinv) then
       write(formatString, '(i2)') size_reduced
       formatString = '(/,a,/,'//trim(formatString)//'('//trim(formatString)//'(2x,es9.2,1x)/))'
@@ -757,15 +734,18 @@ function utilities_maskedCompliance(rot_BC,mask_stress,C)
       write(6,trim(formatString),advance='no') ' S (load) ', transpose(s_reduced)
       if(errmatinv) call IO_error(error_ID=400,ext_msg='utilities_maskedCompliance')
     endif
+    temp99_real = reshape(unpack(reshape(s_reduced,[size_reduced**2]),reshape(mask,[81]),0.0_pReal),[9,9])
   else
     temp99_real = 0.0_pReal
   endif
+
+  utilities_maskedCompliance = math_99to3333(temp99_Real)
+
   if(debugGeneral) then
     write(6,'(/,a,/,9(9(2x,f10.5,1x)/),/)',advance='no') &
       ' Masked Compliance (load) * GPa =', transpose(temp99_Real)*1.0e9_pReal
     flush(6)
   endif
-  utilities_maskedCompliance = math_99to3333(temp99_Real)
 
 end function utilities_maskedCompliance
 
@@ -862,7 +842,7 @@ subroutine utilities_constitutiveResponse(P,P_av,C_volAvg,C_minmaxAvg,&
   write(6,'(/,a,/,3(3(2x,f12.4,1x)/))',advance='no') ' Piola--Kirchhoff stress (lab) / MPa =',&
                                                       transpose(P_av)*1.e-6_pReal
   if(present(rotation_BC)) &
-    P_av = rotation_BC%rotTensor2(P_av)
+    P_av = rotation_BC%rotate(P_av)
   write(6,'(/,a,/,3(3(2x,f12.4,1x)/))',advance='no') ' Piola--Kirchhoff stress       / MPa =',&
                                                       transpose(P_av)*1.e-6_pReal
   flush(6)

src/homogenization.f90

@@ -146,9 +146,7 @@ subroutine homogenization_init
 !--------------------------------------------------------------------------------------------------
 ! allocate and initialize global variables
   allocate(materialpoint_dPdF(3,3,3,3,discretization_nIP,discretization_nElem),       source=0.0_pReal)
-  allocate(materialpoint_F0(3,3,discretization_nIP,discretization_nElem),             source=0.0_pReal)
   materialpoint_F0 = spread(spread(math_I3,3,discretization_nIP),4,discretization_nElem)            ! initialize to identity
-  allocate(materialpoint_F(3,3,discretization_nIP,discretization_nElem),              source=0.0_pReal)
   materialpoint_F = materialpoint_F0                                                                ! initialize to identity
   allocate(materialpoint_subF0(3,3,discretization_nIP,discretization_nElem),          source=0.0_pReal)
   allocate(materialpoint_subF(3,3,discretization_nIP,discretization_nElem),           source=0.0_pReal)
@@ -336,9 +334,7 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt)
               write(6,*) 'Integration point ', i,' at element ', e, ' terminally ill'
               !$OMP END CRITICAL (write2out)
             endif
-            !$OMP CRITICAL (setTerminallyIll)
             terminallyIll = .true.                                                                  ! ...and kills all others
-            !$OMP END CRITICAL (setTerminallyIll)
           else                                                                                      ! cutback makes sense
             materialpoint_subStep(i,e) = subStepSizeHomog * materialpoint_subStep(i,e)              ! crystallite had severe trouble, so do a significant cutback
 

src/lattice.f90

@@ -524,7 +524,7 @@ contains
 !--------------------------------------------------------------------------------------------------
 subroutine lattice_init
 
-  integer :: Nphases, p
+  integer :: Nphases, p,i
   character(len=pStringLen) :: &
     tag  = ''
   real(pReal) :: CoverA
@@ -550,27 +550,11 @@ subroutine lattice_init
   allocate(lattice_mu(Nphases), source=0.0_pReal)
   allocate(lattice_nu(Nphases), source=0.0_pReal)
 
- 
   allocate(lattice_Scleavage(3,3,3,lattice_maxNcleavage,Nphases),source=0.0_pReal)
   allocate(lattice_NcleavageSystem(lattice_maxNcleavageFamily,Nphases),source=0)
 
-  do p = 1, size(config_phase)
-    tag = config_phase(p)%getString('lattice_structure')
-    select case(trim(tag(1:3)))
-      case('iso')
-        lattice_structure(p) = LATTICE_iso_ID
-      case('fcc')
-        lattice_structure(p) = LATTICE_fcc_ID
-      case('bcc')
-        lattice_structure(p) = LATTICE_bcc_ID
-      case('hex')
-        lattice_structure(p) = LATTICE_hex_ID
-      case('bct')
-        lattice_structure(p) = LATTICE_bct_ID
-      case('ort')
-        lattice_structure(p) = LATTICE_ort_ID
-    end select
 
+  do p = 1, size(config_phase)
 
     lattice_C66(1,1,p) = config_phase(p)%getFloat('c11',defaultVal=0.0_pReal)
     lattice_C66(1,2,p) = config_phase(p)%getFloat('c12',defaultVal=0.0_pReal)
@@ -582,9 +566,44 @@ subroutine lattice_init
     lattice_C66(5,5,p) = config_phase(p)%getFloat('c55',defaultVal=0.0_pReal)
     lattice_C66(6,6,p) = config_phase(p)%getFloat('c66',defaultVal=0.0_pReal)
 
- 
     CoverA = config_phase(p)%getFloat('c/a',defaultVal=0.0_pReal)
 
+    tag = config_phase(p)%getString('lattice_structure')
+    select case(tag(1:3))
+      case('iso')
+        lattice_structure(p) = LATTICE_iso_ID
+      case('fcc')
+        lattice_structure(p) = LATTICE_fcc_ID
+      case('bcc')
+        lattice_structure(p) = LATTICE_bcc_ID
+      case('hex')
+        if(CoverA < 1.0_pReal .or. CoverA > 2.0_pReal) call IO_error(131,el=p)
+        lattice_structure(p) = LATTICE_hex_ID
+      case('bct')
+        if(CoverA > 2.0_pReal) call IO_error(131,el=p)
+        lattice_structure(p) = LATTICE_bct_ID
+      case('ort')
+        lattice_structure(p) = LATTICE_ort_ID
+      case default
+        call IO_error(130,ext_msg='lattice_init')
+    end select
+
+    lattice_C66(1:6,1:6,p) = lattice_symmetrizeC66(lattice_structure(p),lattice_C66(1:6,1:6,p))
+
+    lattice_mu(p) = 0.2_pReal *(lattice_C66(1,1,p) -lattice_C66(1,2,p) +3.0_pReal*lattice_C66(4,4,p)) ! (C11iso-C12iso)/2 with C11iso=(3*C11+2*C12+4*C44)/5 and C12iso=(C11+4*C12-2*C44)/5
+    lattice_nu(p) = (          lattice_C66(1,1,p) +4.0_pReal*lattice_C66(1,2,p) -2.0_pReal*lattice_C66(4,4,p)) &
+                  / (4.0_pReal*lattice_C66(1,1,p) +6.0_pReal*lattice_C66(1,2,p) +2.0_pReal*lattice_C66(4,4,p))! C12iso/(C11iso+C12iso) with C11iso=(3*C11+2*C12+4*C44)/5 and C12iso=(C11+4*C12-2*C44)/5
+
+    lattice_C3333(1:3,1:3,1:3,1:3,p) = math_Voigt66to3333(lattice_C66(1:6,1:6,p))                   ! Literature data is Voigt
+    lattice_C66(1:6,1:6,p)           = math_sym3333to66(lattice_C3333(1:3,1:3,1:3,1:3,p))           ! DAMASK uses Mandel-weighting
+
+    do i = 1, 6
+      if (abs(lattice_C66(i,i,p))<tol_math_check) &
+        call IO_error(135,el=i,ip=p,ext_msg='matrix diagonal "el"ement of phase "ip"')
+    enddo
+
+
+    ! should not be part of lattice
     lattice_thermalConductivity33(1,1,p) = config_phase(p)%getFloat('thermal_conductivity11',defaultVal=0.0_pReal)
     lattice_thermalConductivity33(2,2,p) = config_phase(p)%getFloat('thermal_conductivity22',defaultVal=0.0_pReal)
     lattice_thermalConductivity33(3,3,p) = config_phase(p)%getFloat('thermal_conductivity33',defaultVal=0.0_pReal)
@@ -604,10 +623,6 @@ subroutine lattice_init
     lattice_DamageDiffusion33(3,3,p) = config_phase(p)%getFloat( 'damage_diffusion33',defaultVal=0.0_pReal)
     lattice_DamageMobility(p) = config_phase(p)%getFloat( 'damage_mobility',defaultVal=0.0_pReal)
 
-    if ((CoverA < 1.0_pReal .or. CoverA > 2.0_pReal) &
-        .and. lattice_structure(p) == LATTICE_hex_ID) call IO_error(131,el=p)                       ! checking physical significance of c/a
-    if ((CoverA > 2.0_pReal) &
-        .and. lattice_structure(p) == LATTICE_bct_ID) call IO_error(131,el=p)                       ! checking physical significance of c/a
     call lattice_initializeStructure(p, CoverA)
   enddo
 
@@ -624,27 +639,7 @@ subroutine lattice_initializeStructure(myPhase,CoverA)
     CoverA
 
   integer :: &
-   i,  &
+   i
-    myNcleavage
- 
-  lattice_C66(1:6,1:6,myPhase) = lattice_symmetrizeC66(lattice_structure(myPhase),&
-                                                       lattice_C66(1:6,1:6,myPhase))
- 
-  lattice_mu(myPhase) = 0.2_pReal *(  lattice_C66(1,1,myPhase) &
-                                    - lattice_C66(1,2,myPhase) &
-                                    + 3.0_pReal*lattice_C66(4,4,myPhase))                           ! (C11iso-C12iso)/2 with C11iso=(3*C11+2*C12+4*C44)/5 and C12iso=(C11+4*C12-2*C44)/5
-  lattice_nu(myPhase) = (  lattice_C66(1,1,myPhase) &
-                         + 4.0_pReal*lattice_C66(1,2,myPhase) &
-                         - 2.0_pReal*lattice_C66(4,4,myPhase)) &
-                                                              /(  4.0_pReal*lattice_C66(1,1,myPhase) &
-                                                                + 6.0_pReal*lattice_C66(1,2,myPhase) &
-                                                                + 2.0_pReal*lattice_C66(4,4,myPhase))! C12iso/(C11iso+C12iso) with C11iso=(3*C11+2*C12+4*C44)/5 and C12iso=(C11+4*C12-2*C44)/5
-  lattice_C3333(1:3,1:3,1:3,1:3,myPhase) = math_Voigt66to3333(lattice_C66(1:6,1:6,myPhase))         ! Literature data is Voigt
-  lattice_C66(1:6,1:6,myPhase) = math_sym3333to66(lattice_C3333(1:3,1:3,1:3,1:3,myPhase))           ! DAMASK uses Mandel-weighting
-  do i = 1, 6
-    if (abs(lattice_C66(i,i,myPhase))<tol_math_check) &
-      call IO_error(135,el=i,ip=myPhase,ext_msg='matrix diagonal "el"ement of phase "ip"')
-  enddo
 
   do i = 1,3
     lattice_thermalExpansion33 (1:3,1:3,i,myPhase) = lattice_symmetrize33(lattice_structure(myPhase),&
@@ -655,51 +650,34 @@ subroutine lattice_initializeStructure(myPhase,CoverA)
                                                                           lattice_thermalConductivity33  (1:3,1:3,myPhase))
   lattice_DamageDiffusion33      (1:3,1:3,myPhase) = lattice_symmetrize33(lattice_structure(myPhase),&
                                                                           lattice_DamageDiffusion33      (1:3,1:3,myPhase))
-  myNcleavage   = 0
 
   select case(lattice_structure(myPhase))
 
     case (LATTICE_fcc_ID)
-      myNcleavage = lattice_fcc_Ncleavage
       lattice_NcleavageSystem(1:2,myPhase)  = lattice_fcc_NcleavageSystem
- 
+      lattice_Scleavage(1:3,1:3,1:3,1:lattice_fcc_Ncleavage,myPhase) = &
-      lattice_Scleavage(1:3,1:3,1:3,1:myNcleavage,myPhase) = &
       lattice_SchmidMatrix_cleavage(lattice_fcc_ncleavageSystem,'fcc',covera)
 
     case (LATTICE_bcc_ID)
-      myNcleavage = lattice_bcc_Ncleavage
       lattice_NcleavageSystem(1:2,myPhase)  = lattice_bcc_NcleavageSystem
- 
+      lattice_Scleavage(1:3,1:3,1:3,1:lattice_bcc_Ncleavage,myPhase) = &
-      lattice_Scleavage(1:3,1:3,1:3,1:myNcleavage,myPhase) = &
       lattice_SchmidMatrix_cleavage(lattice_bcc_ncleavagesystem,'bcc',covera)
 
     case (LATTICE_hex_ID)
-      myNcleavage = lattice_hex_Ncleavage
       lattice_NcleavageSystem(1:1,myPhase) = lattice_hex_NcleavageSystem
- 
+      lattice_Scleavage(1:3,1:3,1:3,1:lattice_hex_Ncleavage,myPhase) = &
-      lattice_Scleavage(1:3,1:3,1:3,1:myNcleavage,myPhase) = &
       lattice_SchmidMatrix_cleavage(lattice_hex_ncleavagesystem,'hex',covera)
 
-    case (LATTICE_bct_ID)
- 
     case (LATTICE_ort_ID)
-      myNcleavage   = lattice_ort_Ncleavage
       lattice_NcleavageSystem(1:3,myPhase)  = lattice_ort_NcleavageSystem
- 
+      lattice_Scleavage(1:3,1:3,1:3,1:lattice_ort_Ncleavage,myPhase) = &
-      lattice_Scleavage(1:3,1:3,1:3,1:myNcleavage,myPhase) = &
       lattice_SchmidMatrix_cleavage(lattice_ort_NcleavageSystem,'ort',covera)
 
     case (LATTICE_iso_ID)
-      myNcleavage   = lattice_iso_Ncleavage
       lattice_NcleavageSystem(1:1,myPhase)  = lattice_iso_NcleavageSystem
- 
+      lattice_Scleavage(1:3,1:3,1:3,1:lattice_iso_Ncleavage,myPhase) = &
-      lattice_Scleavage(1:3,1:3,1:3,1:myNcleavage,myPhase) = &
       lattice_SchmidMatrix_cleavage(lattice_iso_NcleavageSystem,'iso',covera)
 
-!--------------------------------------------------------------------------------------------------
-! something went wrong
-    case default
-      call IO_error(130,ext_msg='lattice_initializeStructure')
   end select
 
 end subroutine lattice_initializeStructure

src/material.f90

@@ -268,6 +268,7 @@ subroutine material_init
     if(microstructure_Nconstituents(m) < 1) &
          call IO_error(151,m)
   enddo
+  if(homogenization_maxNgrains > size(microstructure_phase,1)) call IO_error(148)
  
   debugOut: if (iand(myDebug,debug_levelExtensive) /= 0) then
     write(6,'(/,a,/)') ' MATERIAL configuration'
@@ -290,6 +291,7 @@ subroutine material_init
 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 ! new mappings
+
   allocate(material_phaseAt(homogenization_maxNgrains,discretization_nElem),                   source=0)
   allocate(material_texture(homogenization_maxNgrains,discretization_nIP,discretization_nElem),source=0)   !this is only needed by plasticity nonlocal
   allocate(material_orientation0(homogenization_maxNgrains,discretization_nIP,discretization_nElem))
@@ -298,15 +300,24 @@ subroutine material_init
      do i = 1, discretization_nIP
        myMicro = discretization_microstructureAt(e)
        do c = 1, homogenization_Ngrains(discretization_homogenizationAt(e))
+         if(microstructure_phase(c,myMicro) > 0) then
            material_phaseAt(c,e)        = microstructure_phase(c,myMicro)
+         else
+           call IO_error(150,ext_msg='phase')
+         endif
+         if(microstructure_texture(c,myMicro) > 0) then
            material_texture(c,i,e)      = microstructure_texture(c,myMicro)
            material_orientation0(c,i,e) = texture_orientation(material_texture(c,i,e))
+         else
+           call IO_error(150,ext_msg='texture')
+         endif
        enddo
      enddo
    enddo
  
   deallocate(microstructure_phase)
   deallocate(microstructure_texture)
+  deallocate(texture_orientation)
  
   
   allocate(material_homogenizationAt,source=discretization_homogenizationAt)
@@ -464,7 +475,7 @@ subroutine material_parseMicrostructure
   real(pReal), dimension(:,:), allocatable :: &
     microstructure_fraction                                                                         !< vol fraction of each constituent in microstructure
   integer :: &
-    microstructure_maxNconstituents                                                                 !< max number of constituents in any phase
+    maxNconstituents                                                                                !< max number of constituents in any phase
  
   allocate(microstructure_Nconstituents(size(config_microstructure)), source=0)
  
@@ -475,10 +486,10 @@ subroutine material_parseMicrostructure
     microstructure_Nconstituents(m) =  config_microstructure(m)%countKeys('(constituent)')
   enddo
  
-  microstructure_maxNconstituents = maxval(microstructure_Nconstituents)
+  maxNconstituents = maxval(microstructure_Nconstituents)
-  allocate(microstructure_phase   (microstructure_maxNconstituents,size(config_microstructure)),source=0)
+  allocate(microstructure_phase   (maxNconstituents,size(config_microstructure)),source=0)
-  allocate(microstructure_texture (microstructure_maxNconstituents,size(config_microstructure)),source=0)
+  allocate(microstructure_texture (maxNconstituents,size(config_microstructure)),source=0)
-  allocate(microstructure_fraction(microstructure_maxNconstituents,size(config_microstructure)),source=0.0_pReal)
+  allocate(microstructure_fraction(maxNconstituents,size(config_microstructure)),source=0.0_pReal)
  
   allocate(strings(1))                                                                              ! Intel 16.0 Bug
   do m=1, size(config_microstructure)

src/results.f90

@@ -485,15 +485,15 @@ end subroutine results_writeScalarDataset_rotation
 !--------------------------------------------------------------------------------------------------
 !> @brief adds the unique mapping from spatial position and constituent ID to results
 !--------------------------------------------------------------------------------------------------
-subroutine results_mapping_constituent(phaseAt,memberAt,label)
+subroutine results_mapping_constituent(phaseAt,memberAtLocal,label)
     
   integer,          dimension(:,:),   intent(in) :: phaseAt                                         !< phase section at (constituent,element)
-  integer,          dimension(:,:,:), intent(in) :: memberAt                                        !< phase member at (constituent,IP,element)
+  integer,                   dimension(:,:,:), intent(in) :: memberAtLocal                          !< phase member at (constituent,IP,element)
-  character(len=*), dimension(:),     intent(in) :: label                                           !< label of each phase section
+  character(len=pStringLen), dimension(:),     intent(in) :: label                                  !< label of each phase section
   
-  integer, dimension(size(memberAt,1),size(memberAt,2),size(memberAt,3)) :: &
+  integer, dimension(size(memberAtLocal,1),size(memberAtLocal,2),size(memberAtLocal,3)) :: &
-    phaseAt_perIP, &
+    phaseAtMaterialpoint, &
-    memberAt_total
+    memberAtGlobal
   integer, dimension(size(label),0:worldsize-1) :: memberOffset                                     !< offset in member counting per process
   integer, dimension(0:worldsize-1)             :: writeSize                                        !< amount of data written per process
   integer(HSIZE_T), dimension(2) :: &
@@ -543,10 +543,10 @@ subroutine results_mapping_constituent(phaseAt,memberAt,label)
   call h5pcreate_f(H5P_DATASET_XFER_F, plist_id, ierr)
   memberOffset = 0
   do i=1, size(label)
-    memberOffset(i,worldrank) = count(phaseAt == i)*size(memberAt,2)                                ! number of points/instance of this process
+    memberOffset(i,worldrank) = count(phaseAt == i)*size(memberAtLocal,2)                                ! number of points/instance of this process
   enddo
   writeSize = 0
-  writeSize(worldrank) = size(memberAt(1,:,:))                                                      ! total number of points by this process
+  writeSize(worldrank) = size(memberAtLocal(1,:,:))                                                      ! total number of points by this process
 
 !--------------------------------------------------------------------------------------------------
 ! MPI settings and communication
@@ -578,14 +578,14 @@ subroutine results_mapping_constituent(phaseAt,memberAt,label)
 
 !---------------------------------------------------------------------------------------------------
 ! expand phaseAt to consider IPs (is not stored per IP)
-  do i = 1, size(phaseAt_perIP,2)
+  do i = 1, size(phaseAtMaterialpoint,2)
-    phaseAt_perIP(:,i,:) = phaseAt
+    phaseAtMaterialpoint(:,i,:) = phaseAt
   enddo
   
 !---------------------------------------------------------------------------------------------------
 ! renumber member from my process to all processes
   do i = 1, size(label)
-    where(phaseAt_perIP == i) memberAt_total = memberAt + sum(memberOffset(i,0:worldrank-1)) -1     ! convert to 0-based
+    where(phaseAtMaterialpoint == i) memberAtGlobal = memberAtLocal + sum(memberOffset(i,0:worldrank-1)) -1     ! convert to 0-based
   enddo
 
 !--------------------------------------------------------------------------------------------------
@@ -596,10 +596,10 @@ subroutine results_mapping_constituent(phaseAt,memberAt,label)
   call h5dcreate_f(loc_id, 'constituent', dtype_id, filespace_id, dset_id, ierr)
   if (ierr < 0) call IO_error(1,ext_msg='results_mapping_constituent: h5dcreate_f')
   
-  call h5dwrite_f(dset_id, name_id, reshape(label(pack(phaseAt_perIP,.true.)),myShape), &
+  call h5dwrite_f(dset_id, name_id, reshape(label(pack(phaseAtMaterialpoint,.true.)),myShape), &
                   myShape, ierr, file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
   if (ierr < 0) call IO_error(1,ext_msg='results_mapping_constituent: h5dwrite_f/name_id')
-  call h5dwrite_f(dset_id, position_id, reshape(pack(memberAt_total,.true.),myShape), &
+  call h5dwrite_f(dset_id, position_id, reshape(pack(memberAtGlobal,.true.),myShape), &
                   myShape, ierr, file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
   if (ierr < 0) call IO_error(1,ext_msg='results_mapping_constituent: h5dwrite_f/position_id')
 
@@ -620,15 +620,15 @@ end subroutine results_mapping_constituent
 !--------------------------------------------------------------------------------------------------
 !> @brief adds the unique mapping from spatial position and constituent ID to results
 !--------------------------------------------------------------------------------------------------
-subroutine results_mapping_materialpoint(homogenizationAt,memberAt,label)
+subroutine results_mapping_materialpoint(homogenizationAt,memberAtLocal,label)
     
   integer,          dimension(:),   intent(in) :: homogenizationAt                                  !< homogenization section at (element)
-  integer,          dimension(:,:), intent(in) :: memberAt                                          !< homogenization member at (IP,element)
+  integer,                   dimension(:,:), intent(in) :: memberAtLocal                            !< homogenization member at (IP,element)
-  character(len=*), dimension(:),   intent(in) :: label                                             !< label of each homogenization section
+  character(len=pStringLen), dimension(:),   intent(in) :: label                                    !< label of each homogenization section
   
-  integer, dimension(size(memberAt,1),size(memberAt,2)) :: &
+  integer, dimension(size(memberAtLocal,1),size(memberAtLocal,2)) :: &
-    homogenizationAt_perIP, &
+    homogenizationAtMaterialpoint, &
-    memberAt_total
+    memberAtGlobal
   integer, dimension(size(label),0:worldsize-1) :: memberOffset                                     !< offset in member counting per process
   integer, dimension(0:worldsize-1)             :: writeSize                                        !< amount of data written per process
   integer(HSIZE_T), dimension(1) :: &
@@ -678,10 +678,10 @@ subroutine results_mapping_materialpoint(homogenizationAt,memberAt,label)
   call h5pcreate_f(H5P_DATASET_XFER_F, plist_id, ierr)
   memberOffset = 0
   do i=1, size(label)
-    memberOffset(i,worldrank) = count(homogenizationAt == i)*size(memberAt,1)                       ! number of points/instance of this process
+    memberOffset(i,worldrank) = count(homogenizationAt == i)*size(memberAtLocal,1)                       ! number of points/instance of this process
   enddo
   writeSize = 0
-  writeSize(worldrank) = size(memberAt)                                                             ! total number of points by this process
+  writeSize(worldrank) = size(memberAtLocal)                                                             ! total number of points by this process
 
 !--------------------------------------------------------------------------------------------------
 ! MPI settings and communication
@@ -713,14 +713,14 @@ subroutine results_mapping_materialpoint(homogenizationAt,memberAt,label)
 
 !---------------------------------------------------------------------------------------------------
 ! expand phaseAt to consider IPs (is not stored per IP)
-  do i = 1, size(homogenizationAt_perIP,1)
+  do i = 1, size(homogenizationAtMaterialpoint,1)
-    homogenizationAt_perIP(i,:) = homogenizationAt
+    homogenizationAtMaterialpoint(i,:) = homogenizationAt
   enddo
   
 !---------------------------------------------------------------------------------------------------
 ! renumber member from my process to all processes
   do i = 1, size(label)
-    where(homogenizationAt_perIP == i) memberAt_total = memberAt + sum(memberOffset(i,0:worldrank-1)) - 1  ! convert to 0-based
+    where(homogenizationAtMaterialpoint == i) memberAtGlobal = memberAtLocal + sum(memberOffset(i,0:worldrank-1)) - 1  ! convert to 0-based
   enddo
 
 !--------------------------------------------------------------------------------------------------
@@ -731,10 +731,10 @@ subroutine results_mapping_materialpoint(homogenizationAt,memberAt,label)
   call h5dcreate_f(loc_id, 'materialpoint', dtype_id, filespace_id, dset_id, ierr)
   if (ierr < 0) call IO_error(1,ext_msg='results_mapping_materialpoint: h5dcreate_f')
   
-  call h5dwrite_f(dset_id, name_id, reshape(label(pack(homogenizationAt_perIP,.true.)),myShape), &
+  call h5dwrite_f(dset_id, name_id, reshape(label(pack(homogenizationAtMaterialpoint,.true.)),myShape), &
                   myShape, ierr, file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
   if (ierr < 0) call IO_error(1,ext_msg='results_mapping_materialpoint: h5dwrite_f/name_id')
-  call h5dwrite_f(dset_id, position_id, reshape(pack(memberAt_total,.true.),myShape), &
+  call h5dwrite_f(dset_id, position_id, reshape(pack(memberAtGlobal,.true.),myShape), &
                   myShape, ierr, file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
   if (ierr < 0) call IO_error(1,ext_msg='results_mapping_materialpoint: h5dwrite_f/position_id')