new functions (takeover from old branch)

python/damask/dadf5.py

@@ -535,8 +535,10 @@ class DADF5():
               'label': 'sigma',
               'meta':  {
                         'Unit':        P['meta']['Unit'],
-                        'Description': 'Cauchy stress calculated from {} ({}) '.format(P['label'],P['meta']['Description'])+\
+                        'Description': 'Cauchy stress calculated from {} ({}) '.format(P['label'],
-                                       'and deformation gradient {} ({})'.format(F['label'],F['meta']['Description']),
+                                                                                       P['meta']['Description'])+\
+                                       'and deformation gradient {} ({})'.format(F['label'],
+                                                                                 F['meta']['Description']),
                         'Creator':     'dadf5.py:add_Cauchy v{}'.format(version)
                         }
               }
@@ -604,6 +606,96 @@ class DADF5():
     self.__add_generic_pointwise(__add_deviator,requested)
 
 
+  def add_eigenvalues(self,x):
+    """
+    Add eigenvalues of symmetric tensor.
+
+    Parameters
+    ----------
+    x : str
+      Label of the dataset containing a symmetric tensor.
+
+    """
+    def __add_eigenvalue(x):
+
+      return {
+              'data': mechanics.eigenvalues(x['data']),
+              'label': 'lambda({})'.format(x['label']),
+              'meta' : {
+                        'Unit':         x['meta']['Unit'],
+                        'Description': 'Eigenvalues of {} ({})'.format(x['label'],x['meta']['Description']),
+                        'Creator':     'dadf5.py:add_eigenvalues v{}'.format(version)
+                       }
+              }
+    requested = [{'label':x,'arg':'x'}]
+
+    self.__add_generic_pointwise(__add_eigenvalue,requested)
+
+
+  def add_eigenvectors(self,x):
+    """
+    Add eigenvectors of symmetric tensor.
+
+    Parameters
+    ----------
+    x : str
+      Label of the dataset containing a symmetric tensor.
+
+    """
+    def __add_eigenvector(x):
+
+      return {
+              'data': mechanics.eigenvectors(x['data']),
+              'label': 'v({})'.format(x['label']),
+              'meta' : {
+                        'Unit':         '1',
+                        'Description': 'Eigenvectors of {} ({})'.format(x['label'],x['meta']['Description']),
+                        'Creator':     'dadf5.py:add_eigenvectors v{}'.format(version)
+                       }
+              }
+    requested = [{'label':x,'arg':'x'}]
+
+    self.__add_generic_pointwise(__add_eigenvector,requested)
+
+
+  def add_IPFcolor(self,q,p):
+    """
+    Add RGB color tuple of inverse pole figure (IPF) color.
+
+    Parameters
+    ----------
+    orientation : str
+      Label of the dataset containing the orientation data as quaternions.
+    pole : list of int
+      Pole direction as Miller indices. Default value is [0, 0, 1].
+
+    """
+    def __add_IPFcolor(orientation,pole):
+
+      lattice   = orientation['meta']['Lattice']
+      unit_pole = pole/np.linalg.norm(pole)
+      colors    = np.empty((len(orientation['data']),3),np.uint8)
+
+      for i,q in enumerate(orientation['data']):
+         rot = Rotation(np.array([q['w'],q['x'],q['y'],q['z']]))
+         orientation = Orientation(rot,lattice = lattice).reduced()
+         colors[i]   = np.uint8(orientation.IPFcolor(unit_pole)*255)
+      return {
+              'data': colors,
+              'label': 'IPFcolor_[{} {} {}]'.format(*pole),
+              'meta' : {
+                        'Unit':        'RGB (8bit)',
+                        'Lattice':     lattice,
+                        'Description': 'Inverse Pole Figure colors',
+                        'Creator':     'dadf5.py:addIPFcolor v{}'.format(version)
+                       }
+             }
+
+    requested = [{'label':'orientation','arg':'orientation'}]
+
+    self.__add_generic_pointwise(__add_IPFcolor,requested,{'pole':pole})
+
+
   def add_maximum_shear(self,x):
     """
     Add maximum shear components of symmetric tensor.
@@ -660,6 +752,84 @@ class DADF5():
     self.__add_generic_pointwise(__add_Mises,requested)
 
 
+  def add_PK2(self,F='F',P='P'):
+    """
+    Add 2. Piola-Kirchhoff calculated from 1. Piola-Kirchhoff stress and deformation gradient.
+
+    Parameters
+    ----------
+    P : str, optional
+      Label of the dataset containing the 1. Piola-Kirchhoff stress. Default value is ‘P’.
+    F : str, optional
+      Label of the dataset containing the deformation gradient. Default value is ‘F’.
+
+    """
+    def __add_PK2(F,P):
+
+      return {
+              'data':  mechanics.PK2(F['data'],P['data']),
+              'label': 'S',
+              'meta':  {
+                        'Unit':        P['meta']['Unit'],
+                        'Description': '2. Kirchhoff stress calculated from {} ({}) '.format(P['label'],
+                                                                                             P['meta']['Description'])+\
+                                       'and deformation gradient {} ({})'.format(F['label'],
+                                                                                 F['meta']['Description']),
+                        'Creator':     'dadf5.py:add_PK2 v{}'.format(version)
+                        }
+              }
+
+    requested = [{'label':F,'arg':'F'},
+                 {'label':P,'arg':'P'},]
+
+    self.__add_generic_pointwise(__add_PK2,requested)
+
+
+  def addPole(self,q,p,polar=False):
+    """
+    Add coordinates of stereographic projection of given direction (pole) in crystal frame.
+
+    Parameters
+    ----------
+    q : str
+      Label of the dataset containing the crystallographic orientation as a quaternion.
+    p : numpy.array of shape (3)
+      Pole (direction) in crystal frame.
+    polar : bool, optional
+      Give pole in polar coordinates. Default is false.
+
+    """
+    def __addPole(orientation,pole):
+
+      pole       = np.array(pole)
+      unit_pole /= np.linalg.norm(pole)
+      coords = np.empty((len(orientation['data']),2))
+
+      for i,q in enumerate(orientation['data']):
+        o = Rotation(np.array([q['w'],q['x'],q['y'],q['z']]))
+        rotatedPole = o*pole                                # rotate pole according to crystal orientation
+        (x,y) = rotatedPole[0:2]/(1.+abs(pole[2]))          # stereographic projection
+
+        if polar is True:
+          coords[i] = [np.sqrt(x*x+y*y),np.arctan2(y,x)]
+        else:
+          coords[i] = [x,y]
+
+      return {
+              'data': coords,
+              'label': 'Pole',
+              'meta' : {
+                        'Unit': '1',
+                        'Description': 'Coordinates of stereographic projection of given direction (pole) in crystal frame',
+                        'Creator' : 'dadf5.py:addPole v{}'.format(version)
+                       }
+             }
+
+    requested = [{'label':'orientation','arg':'orientation'}]
+
+    self.__add_generic_pointwise(__addPole,requested,{'pole':pole})
+
+
   def add_norm(self,x,ord=None):
     """
     Add the norm of vector or tensor.