DAMASK_EICMD/python/damask/orientation.py

import numpy as np

from .lattice  import Lattice
from .rotation import Rotation

class Orientation:
  """
  Crystallographic orientation.

  A crystallographic orientation contains a rotation and a lattice.
  """

  __slots__ = ['rotation','lattice']

  def __repr__(self):
    """Report lattice type and orientation."""
    return self.lattice.__repr__()+'\n'+self.rotation.__repr__()

  def __init__(self, rotation, lattice):
    """
    New orientation from rotation and lattice.

    Parameters
    ----------
    rotation : Rotation
        Rotation specifying the lattice orientation.
    lattice : Lattice
        Lattice type of the crystal.

    """
    if isinstance(lattice, Lattice):
      self.lattice = lattice
    else:
      self.lattice = Lattice(lattice)                                                               # assume string

    if isinstance(rotation, Rotation):
      self.rotation = rotation
    else:
      self.rotation = Rotation.fromQuaternion(rotation)                                             # assume quaternion

  def disorientation(self,
                     other,
                     SST = True,
                     symmetries = False):
    """
    Disorientation between myself and given other orientation.

    Rotation axis falls into SST if SST == True.
    (Currently requires same symmetry for both orientations.
     Look into A. Heinz and P. Neumann 1991 for cases with differing sym.)
    """
    if self.lattice.symmetry != other.lattice.symmetry:
      raise NotImplementedError('disorientation between different symmetry classes not supported yet.')

    mySymEqs    =  self.equivalentOrientations() if SST else self.equivalentOrientations([0])     # take all or only first sym operation
    otherSymEqs = other.equivalentOrientations()

    for i,sA in enumerate(mySymEqs):
      aInv = sA.rotation.inversed()
      for j,sB in enumerate(otherSymEqs):
        b = sB.rotation
        r = b*aInv
        for k in range(2):
          r.inverse()
          breaker = self.lattice.symmetry.inFZ(r.asRodrigues(vector=True)) \
                    and (not SST or other.lattice.symmetry.inDisorientationSST(r.asRodrigues(vector=True)))
          if breaker: break
        if breaker: break
      if breaker: break

    return (Orientation(r,self.lattice), i,j, k == 1) if symmetries else r                          # disorientation ...
                                                                                                    # ... own sym, other sym,
                                                                                                    # self-->other: True, self<--other: False
  def inFZ(self):
    return self.lattice.symmetry.inFZ(self.rotation.asRodrigues(vector=True))


  def equivalentOrientations(self,members=[]):
    """List of orientations which are symmetrically equivalent."""
    try:
      iter(members)                                                                                 # asking for (even empty) list of members?
    except TypeError:
      return self.__class__(self.lattice.symmetry.symmetryOperations(members)*self.rotation,self.lattice) # no, return rotation object
    else:
      return [self.__class__(q*self.rotation,self.lattice) \
                                    for q in self.lattice.symmetry.symmetryOperations(members)]           # yes, return list of rotations

  def relatedOrientations(self,model):
    """List of orientations related by the given orientation relationship."""
    r = self.lattice.relationOperations(model)
    return [self.__class__(o*self.rotation,r['lattice']) for o in r['rotations']]


  def reduced(self):
    """Transform orientation to fall into fundamental zone according to symmetry."""
    for me in self.equivalentOrientations():
      if self.lattice.symmetry.inFZ(me.rotation.asRodrigues(vector=True)): break

    return self.__class__(me.rotation,self.lattice)


  def inversePole(self,
                  axis,
                  proper = False,
                  SST = True):
    """Axis rotated according to orientation (using crystal symmetry to ensure location falls into SST)."""
    if SST:                                                                                         # pole requested to be within SST
      for i,o in enumerate(self.equivalentOrientations()):                                          # test all symmetric equivalent quaternions
        pole = o.rotation*axis                                                                      # align crystal direction to axis
        if self.lattice.symmetry.inSST(pole,proper): break                                          # found SST version
    else:
      pole = self.rotation*axis                                                                     # align crystal direction to axis

    return (pole,i if SST else 0)


  def IPFcolor(self,axis):
    """TSL color of inverse pole figure for given axis."""
    color = np.zeros(3,'d')

    for o in self.equivalentOrientations():
      pole = o.rotation*axis                                                                        # align crystal direction to axis
      inSST,color = self.lattice.symmetry.inSST(pole,color=True)
      if inSST: break

    return color


  @staticmethod
  def fromAverage(orientations,
                  weights = []):
    """Create orientation from average of list of orientations."""
    if not all(isinstance(item, Orientation) for item in orientations):
      raise TypeError("Only instances of Orientation can be averaged.")

    closest = []
    ref = orientations[0]
    for o in orientations:
      closest.append(o.equivalentOrientations(
                     ref.disorientation(o,
                                        SST = False,                                                # select (o[ther]'s) sym orientation
                                        symmetries = True)[2]).rotation)                            # with lowest misorientation

    return Orientation(Rotation.fromAverage(closest,weights),ref.lattice)


  def average(self,other):
    """Calculate the average rotation."""
    return Orientation.fromAverage([self,other])