예제 #1
0
파일: calc.py 프로젝트: jamesmudd/diffcalc
 def _clear(self, name=None):
     # NOTE the Diffraction calculator is expecting this object to exist in
     # the long run. We can't remove this entire object, and recreate it.
     # It also contains a required link to the angle calculator.
     reflist = ReflectionList(self._geometry,
                              self._get_diffractometer_axes_names())
     reference = YouReference(self._get_UB)
     self._state = UBCalcState(name=name,
                               reflist=reflist,
                               reference=reference)
     self._U = None
     self._UB = None
     self._state.configure_calc_type()
예제 #2
0
파일: calc.py 프로젝트: robwalton/diffcalc
 def _clear(self, name=None):
     # NOTE the Diffraction calculator is expecting this object to exist in
     # the long run. We can't remove this entire object, and recreate it.
     # It also contains a required link to the angle calculator.
     reflist = ReflectionList(self._geometry, self._diffractometer_axes_names)
     self._state = UBCalcState(name=name, reflist=reflist)
     self._U = None
     self._UB = None
     self._state.configure_calc_type()
예제 #3
0
 def _clear(self, name=None):
     # NOTE the Diffraction calculator is expecting this object to exist in
     # the long run. We can't remove this entire object, and recreate it.
     # It also contains a required link to the angle calculator.
     reflist = ReflectionList(
         settings.geometry,
         self._get_diffractometer_axes_names(),
         multiplier=settings.hardware.energyScannableMultiplierToGetKeV)
     orientlist = OrientationList(settings.geometry,
                                  self._get_diffractometer_axes_names())
     reference = YouReference(self._get_UB)
     reference._set_n_hkl_configured(settings.reference_vector)
     surface = YouReference(self._get_UB)
     surface._set_n_phi_configured(settings.surface_vector)
     self._state = UBCalcState(name=name,
                               reflist=reflist,
                               orientlist=orientlist,
                               reference=reference,
                               surface=surface)
     self._U = None
     self._UB = None
     self._state.configure_calc_type()
예제 #4
0
class UBCalculation:
    """A UB matrix calculation for an experiment.

    Contains the parameters for the _crystal under test, a list of measured
    reflections and, if its been calculated, a UB matrix to be used by the rest
    of the code.
    """
    def __init__(self,
                 persister,
                 strategy,
                 include_sigtau=True,
                 include_reference=True):

        # The diffractometer geometry is required to map the internal angles
        # into those used by this diffractometer (for display only)

        self._persister = persister
        self._strategy = strategy
        self.include_sigtau = include_sigtau
        self.include_reference = include_reference
        try:
            self._tobj = CoordinateConverter(
                transform=settings.geometry.beamline_axes_transform)
        except AttributeError:
            self._tobj = CoordinateConverter(transform=None)
        self._clear()

    def _get_diffractometer_axes_names(self):
        return settings.hardware.get_axes_names()

    def _clear(self, name=None):
        # NOTE the Diffraction calculator is expecting this object to exist in
        # the long run. We can't remove this entire object, and recreate it.
        # It also contains a required link to the angle calculator.
        reflist = ReflectionList(
            settings.geometry,
            self._get_diffractometer_axes_names(),
            multiplier=settings.hardware.energyScannableMultiplierToGetKeV)
        orientlist = OrientationList(settings.geometry,
                                     self._get_diffractometer_axes_names())
        reference = YouReference(self._get_UB)
        reference._set_n_hkl_configured(settings.reference_vector)
        surface = YouReference(self._get_UB)
        surface._set_n_phi_configured(settings.surface_vector)
        self._state = UBCalcState(name=name,
                                  reflist=reflist,
                                  orientlist=orientlist,
                                  reference=reference,
                                  surface=surface)
        self._U = None
        self._UB = None
        self._state.configure_calc_type()

### State ###

    def start_new(self, name):
        """Start new UB matrix calculation.
        
        Creates a new blank UB matrix calculation.
        
        Parameters
        ----------
        name: str
            Name of a new UB matrix calculation
        """
        # Create storage object if name does not exist (TODO)
        self._clear(name)
        self.save()

    def load(self, name):
        state = self._persister.load(name)
        if isinstance(self._persister, UBCalculationJSONPersister):
            self._state = self._persister.encoder.decode_ubcalcstate(
                state, settings.geometry,
                self._get_diffractometer_axes_names(),
                settings.hardware.energyScannableMultiplierToGetKeV)
            self._state.reference.get_UB = self._get_UB
            self._state.surface.get_UB = self._get_UB
        elif isinstance(self._persister, UBCalculationPersister):
            self._state = state
        else:
            raise DiffcalcException('Unexpected persister type: ' +
                                    str(self._persister))
        if self._state.manual_U is not None:
            self._U = self._state.manual_U
            self._UB = self._U * self._state.crystal.B
            self.save()
        elif self._state.manual_UB is not None:
            self._UB = self._state.manual_UB
            self.save()
        elif self._state.is_okay_to_autocalculate_ub:
            try:
                self.calculate_UB(self._state.or0, self._state.or1)
            except Exception, e:
                print e
        else:
예제 #5
0
파일: calc.py 프로젝트: jamesmudd/diffcalc
class UBCalculation:
    """A UB matrix calculation for an experiment.

    Contains the parameters for the _crystal under test, a list of measured
    reflections and, if its been calculated, a UB matrix to be used by the rest
    of the code.
    """
    def __init__(self,
                 hardware,
                 diffractometerPluginObject,
                 persister,
                 strategy,
                 include_sigtau=True,
                 include_reference=True):

        # The diffractometer geometry is required to map the internal angles
        # into those used by this diffractometer (for display only)

        self._hardware = hardware
        self._geometry = diffractometerPluginObject
        self._persister = persister
        self._strategy = strategy
        self.include_sigtau = include_sigtau
        self.include_reference = include_reference
        self._clear()

    def _get_diffractometer_axes_names(self):
        return self._hardware.get_axes_names()

    def _clear(self, name=None):
        # NOTE the Diffraction calculator is expecting this object to exist in
        # the long run. We can't remove this entire object, and recreate it.
        # It also contains a required link to the angle calculator.
        reflist = ReflectionList(self._geometry,
                                 self._get_diffractometer_axes_names())
        reference = YouReference(self._get_UB)
        self._state = UBCalcState(name=name,
                                  reflist=reflist,
                                  reference=reference)
        self._U = None
        self._UB = None
        self._state.configure_calc_type()

### State ###

    def start_new(self, name):
        """start_new(name) --- creates a new blank ub calculation"""
        # Create storage object if name does not exist (TODO)
        if name in self._persister.list():
            print(
                "No UBCalculation started: There is already a calculation "
                "called: " + name)
            print "Saved calculations: " + repr(self._persister.list())
            return
        self._clear(name)
        self.save()

    def load(self, name):
        state = self._persister.load(name)
        if isinstance(self._persister, UBCalculationJSONPersister):
            self._state = decode_ubcalcstate(
                state, self._geometry, self._get_diffractometer_axes_names())
            self._state.reference.get_UB = self._get_UB
        elif isinstance(self._persister, UBCalculationPersister):
            self._state = state
        else:
            raise Exception('Unexpected persister type: ' +
                            str(self._persister))
        if self._state.manual_U is not None:
            self.set_U_manually(self._state.manual_U)
        elif self._state.manual_UB is not None:
            self.set_UB_manually(self._state.manual_UB)
        elif self._state.or0 is not None:
            if self._state.or1 is None:
                self.calculate_UB_from_primary_only()
            else:
                self.calculate_UB()
        else:
            pass

    def save(self):
        self.saveas(self._state.name)

    def saveas(self, name):
        self._state.name = name
        self._persister.save(self._state, name)

    def listub(self):
        return self._persister.list()

    def listub_metadata(self):
        return self._persister.list_metadata()

    def remove(self, name):
        self._persister.remove(name)
        if self._state == name:
            self._clear(name)

    def getState(self):
        return self._state.getState()

    def __str__(self):

        if self._state.name is None:
            return "<<< No UB calculation started >>>"
        lines = []
        lines.append(bold("UBCALC"))
        lines.append("")
        lines.append("   name:".ljust(WIDTH) + self._state.name.rjust(9))

        if self.include_sigtau:
            lines.append("")
            lines.append("   sigma:".ljust(WIDTH) +
                         ("% 9.5f" % self._state.sigma).rjust(9))
            lines.append("   tau:".ljust(WIDTH) +
                         ("% 9.5f" % self._state.tau).rjust(9))

        if self.include_reference:
            lines.append("")
            ub_calculated = self._UB is not None
            lines.extend(self._state.reference.repr_lines(
                ub_calculated, WIDTH))

        lines.append("")
        lines.append(bold("CRYSTAL"))
        lines.append("")

        if self._state.crystal is None:
            lines.append("   <<< none specified >>>")
        else:
            lines.extend(self._state.crystal.str_lines())

        lines.append("")
        lines.append(bold("UB MATRIX"))
        lines.append("")

        if self._UB is None:
            lines.append("   <<< none calculated >>>")
        else:
            lines.extend(self.str_lines_u())
            lines.append("")
            lines.extend(self.str_lines_u_angle_and_axis())
            lines.append("")
            lines.extend(self.str_lines_ub())

        lines.append("")
        lines.append(bold("REFLECTIONS"))
        lines.append("")

        lines.extend(self._state.reflist.str_lines())

        return '\n'.join(lines)

    def str_lines_u(self):
        lines = []
        fmt = "% 9.5f % 9.5f % 9.5f"
        U = self.U
        lines.append("   U matrix:".ljust(WIDTH) + fmt %
                     (z(U[0, 0]), z(U[0, 1]), z(U[0, 2])))
        lines.append(' ' * WIDTH + fmt % (z(U[1, 0]), z(U[1, 1]), z(U[1, 2])))
        lines.append(' ' * WIDTH + fmt % (z(U[2, 0]), z(U[2, 1]), z(U[2, 2])))
        return lines

    def str_lines_u_angle_and_axis(self):
        lines = []
        fmt = "% 9.5f % 9.5f % 9.5f"
        y = matrix('0; 0; 1')
        rotation_axis = cross3(y, self.U * y)
        if abs(norm(rotation_axis)) < SMALL:
            lines.append("   U angle:".ljust(WIDTH) + "  0")
        else:
            rotation_axis = rotation_axis * (1 / norm(rotation_axis))
            cos_rotation_angle = dot3(y, self.U * y)
            rotation_angle = acos(cos_rotation_angle)

            lines.append("      angle:".ljust(WIDTH) + "% 9.5f" %
                         (rotation_angle * TODEG))
            lines.append("       axis:".ljust(WIDTH) +
                         fmt % tuple((rotation_axis.T).tolist()[0]))

        return lines

    def str_lines_ub(self):
        lines = []
        fmt = "% 9.5f % 9.5f % 9.5f"
        UB = self.UB
        lines.append("   UB matrix:".ljust(WIDTH) + fmt %
                     (z(UB[0, 0]), z(UB[0, 1]), z(UB[0, 2])))
        lines.append(' ' * WIDTH + fmt %
                     (z(UB[1, 0]), z(UB[1, 1]), z(UB[1, 2])))
        lines.append(' ' * WIDTH + fmt %
                     (z(UB[2, 0]), z(UB[2, 1]), z(UB[2, 2])))
        return lines

    @property
    def name(self):
        return self._state.name
### Lattice ###

    def set_lattice(self, name, *shortform):
        """
        Converts a list shortform crystal parameter specification to a six-long
        tuple returned as . Returns None if wrong number of input args. See
        set_lattice() for a description of the shortforms supported.

        shortformLattice -- a tuple as follows:
             [a]         - assumes cubic
           [a,b])       - assumes tetragonal
           [a,b,c])     - assumes ortho
           [a,b,c,gam]) - assumes mon/hex gam different from 90.
           [a,b,c,alp,bet,gam]) - for arbitrary
           where all measurements in angstroms and angles in degrees
        """
        self._set_lattice_without_saving(name, *shortform)
        self.save()

    def _set_lattice_without_saving(self, name, *shortform):
        sf = shortform
        if len(sf) == 1:
            fullform = (sf[0], sf[0], sf[0], 90., 90., 90.)  # cubic
        elif len(sf) == 2:
            fullform = (sf[0], sf[0], sf[1], 90., 90., 90.)  # tetragonal
        elif len(sf) == 3:
            fullform = (sf[0], sf[1], sf[2], 90., 90., 90.)  # ortho
        elif len(sf) == 4:
            fullform = (sf[0], sf[1], sf[2], 90., 90., sf[3])  # mon/hex gam
            # not 90
        elif len(sf) == 5:
            raise ValueError("wrong length input to set_lattice")
        elif len(sf) == 6:
            fullform = sf  # triclinic/arbitrary
        else:
            raise ValueError("wrong length input to set_lattice")
        self._set_lattice(name, *fullform)

    def _set_lattice(self, name, a, b, c, alpha, beta, gamma):
        """set lattice parameters in degrees"""
        if self._state.name is None:
            raise DiffcalcException(
                "Cannot set lattice until a UBCalcaluation has been started "
                "with newubcalc")
        self._state.crystal = CrystalUnderTest(name, a, b, c, alpha, beta,
                                               gamma)
        # Clear U and UB if these exist
        if self._U is not None:  # (UB will also exist)
            print "Warning: the old UB calculation has been cleared."
            print "         Use 'calcub' to recalculate with old reflections."

### Surface normal stuff ###

    def _gettau(self):
        """
        Returns tau (in degrees): the (minus) ammount of phi axis rotation ,
        that together with some chi axis rotation (minus sigma) brings the
        optical surface normal parallelto the omega axis.
        """
        return self._state.tau

    def _settau(self, tau):
        self._state.tau = tau
        self.save()

    tau = property(_gettau, _settau)

    def _getsigma(self):
        """
        Returns sigma (in degrees): the (minus) ammount of phi axis rotation ,
        that together with some phi axis rotation (minus tau) brings the
        optical surface normal parallel to the omega axis.
        """
        return self._state.sigma

    def _setsigma(self, sigma):
        self.state._sigma = sigma
        self.save()

    sigma = property(_getsigma, _setsigma)

    ### Reference vector ###

    def _get_n_phi(self):
        return self._state.reference.n_phi

    n_phi = property(_get_n_phi)

    def set_n_phi_configured(self, n_phi):
        self._state.reference.n_phi_configured = n_phi
        self.save()

    def set_n_hkl_configured(self, n_hkl):
        self._state.reference.n_hkl_configured = n_hkl
        self.save()

    def print_reference(self):
        print '\n'.join(
            self._state.reference.repr_lines(self.is_ub_calculated()))

### Reflections ###

    def add_reflection(self, h, k, l, position, energy, tag, time):
        """add_reflection(h, k, l, position, tag=None) -- adds a reflection

        position is in degrees and in the systems internal representation.
        """
        if self._state.reflist is None:
            raise DiffcalcException("No UBCalculation loaded")
        self._state.reflist.add_reflection(h, k, l, position, energy, tag,
                                           time)
        self.save()  # incase autocalculateUbAndReport fails

        # If second reflection has just been added then calculateUB
        if len(self._state.reflist) == 2:
            self._autocalculateUbAndReport()
        self.save()

    def edit_reflection(self, num, h, k, l, position, energy, tag, time):
        """
        edit_reflection(num, h, k, l, position, tag=None) -- adds a reflection

        position is in degrees and in the systems internal representation.
        """
        if self._state.reflist is None:
            raise DiffcalcException("No UBCalculation loaded")
        self._state.reflist.edit_reflection(num, h, k, l, position, energy,
                                            tag, time)

        # If first or second reflection has been changed and there are at least
        # two reflections then recalculate  UB
        if (num == 1 or num == 2) and len(self._state.reflist) >= 2:
            self._autocalculateUbAndReport()
        self.save()

    def get_reflection(self, num):
        """--> ( [h, k, l], position, energy, tag, time
        num starts at 1, position in degrees"""
        return self._state.reflist.getReflection(num)

    def get_reflection_in_external_angles(self, num):
        """--> ( [h, k, l], position, energy, tag, time
        num starts at 1, position in degrees"""
        return self._state.reflist.get_reflection_in_external_angles(num)

    def get_number_reflections(self):
        return 0 if self._state.reflist is None else len(self._state.reflist)

    def del_reflection(self, reflectionNumber):
        self._state.reflist.removeReflection(reflectionNumber)
        if ((reflectionNumber == 1 or reflectionNumber == 2)
                and (self._U != None)):
            self._autocalculateUbAndReport()
        self.save()

    def swap_reflections(self, num1, num2):
        self._state.reflist.swap_reflections(num1, num2)
        if ((num1 == 1 or num1 == 2 or num2 == 1 or num2 == 2)
                and (self._U != None)):
            self._autocalculateUbAndReport()
        self.save()

    def _autocalculateUbAndReport(self):
        if len(self._state.reflist) < 2:
            pass
        elif self._state.crystal is None:
            print(
                "Not calculating UB matrix as no lattice parameters have "
                "been specified.")
        elif not self._state.is_okay_to_autocalculate_ub:
            print(
                "Not calculating UB matrix as it has been manually set. "
                "Use 'calcub' to explicitly recalculate it.")
        else:  # okay to autocalculate
            if self._UB is None:
                print "Calculating UB matrix."
            else:
                print "Recalculating UB matrix."
            self.calculate_UB()

#    @property
#    def reflist(self):
#        return self._state.reflist
### Calculations ###

    def set_U_manually(self, m):
        """Manually sets U. matrix must be 3*3 Jama or python matrix.
        Turns off aution UB calcualtion."""

        # Check matrix is a 3*3 Jama matrix
        if m.__class__ != matrix:
            m = matrix(m)  # assume its a python matrix
        if m.shape[0] != 3 or m.shape[1] != 3:
            raise ValueError("Expects 3*3 matrix")

        if self._UB is None:
            print "Calculating UB matrix."
        else:
            print "Recalculating UB matrix."

        self._state.configure_calc_type(manual_U=m)
        self._U = m
        if self._state.crystal is None:
            raise DiffcalcException(
                "A crystal must be specified before manually setting U")
        self._UB = self._U * self._state.crystal.B
        print(
            "NOTE: A new UB matrix will not be automatically calculated "
            "when the orientation reflections are modified.")
        self.save()

    def set_UB_manually(self, m):
        """Manually sets UB. matrix must be 3*3 Jama or python matrix.
        Turns off aution UB calcualtion."""

        # Check matrix is a 3*3 Jama matrix
        if m.__class__ != matrix:
            m = matrix(m)  # assume its a python matrix
        if m.shape[0] != 3 or m.shape[1] != 3:
            raise ValueError("Expects 3*3 matrix")

        self._state.configure_calc_type(manual_UB=m)
        self._UB = m
        self.save()

    @property
    def U(self):
        if self._U is None:
            raise DiffcalcException(
                "No U matrix has been calculated during this ub calculation")
        return self._U

    @property
    def UB(self):
        return self._get_UB()

    def is_ub_calculated(self):
        return self._UB is not None

    def _get_UB(self):
        if not self.is_ub_calculated():
            raise DiffcalcException(
                "No UB matrix has been calculated during this ub calculation")
        else:
            return self._UB

    def calculate_UB(self):
        """
        Calculate orientation matrix. Uses first two orientation reflections
        as in Busang and Levy, but for the diffractometer in Lohmeier and
        Vlieg.
        """

        # Major variables:
        # h1, h2: user input reciprical lattice vectors of the two reflections
        # h1c, h2c: user input vectors in cartesian crystal plane
        # pos1, pos2: measured diffractometer positions of the two reflections
        # u1a, u2a: measured reflection vectors in alpha frame
        # u1p, u2p: measured reflection vectors in phi frame

        # Get hkl and angle values for the first two refelctions
        if self._state.reflist is None:
            raise DiffcalcException("Cannot calculate a U matrix until a "
                                    "UBCalculation has been started with "
                                    "'newub'")
        try:
            (h1, pos1, _, _, _) = self._state.reflist.getReflection(1)
            (h2, pos2, _, _, _) = self._state.reflist.getReflection(2)
        except IndexError:
            raise DiffcalcException(
                "Two reflections are required to calculate a u matrix")
        h1 = matrix([h1]).T  # row->column
        h2 = matrix([h2]).T
        pos1.changeToRadians()
        pos2.changeToRadians()

        # Compute the two reflections' reciprical lattice vectors in the
        # cartesian crystal frame
        B = self._state.crystal.B
        h1c = B * h1
        h2c = B * h2

        u1p = self._strategy.calculate_q_phi(pos1)
        u2p = self._strategy.calculate_q_phi(pos2)

        # Create modified unit vectors t1, t2 and t3 in crystal and phi systems
        t1c = h1c
        t3c = cross3(h1c, h2c)
        t2c = cross3(t3c, t1c)

        t1p = u1p  # FIXED from h1c 9July08
        t3p = cross3(u1p, u2p)
        t2p = cross3(t3p, t1p)

        # ...and nornmalise and check that the reflections used are appropriate
        SMALL = 1e-4  # Taken from Vlieg's code
        e = DiffcalcException("Invalid orientation reflection(s)")

        def normalise(m):
            d = norm(m)
            if d < SMALL:
                raise e
            return m / d

        t1c = normalise(t1c)
        t2c = normalise(t2c)
        t3c = normalise(t3c)

        t1p = normalise(t1p)
        t2p = normalise(t2p)
        t3p = normalise(t3p)

        Tc = hstack([t1c, t2c, t3c])
        Tp = hstack([t1p, t2p, t3p])
        self._state.configure_calc_type(or0=1, or1=2)
        self._U = Tp * Tc.I
        self._UB = self._U * B
        self.save()

    def calculate_UB_from_primary_only(self):
        """
        Calculate orientation matrix with the shortest absolute angle change.
        Uses first orientation reflection
        """

        # Algorithm from http://www.j3d.org/matrix_faq/matrfaq_latest.html

        # Get hkl and angle values for the first two refelctions
        if self._state.reflist is None:
            raise DiffcalcException(
                "Cannot calculate a u matrix until a UBCalcaluation has been "
                "started with newub")
        try:
            (h, pos, _, _, _) = self._state.reflist.getReflection(1)
        except IndexError:
            raise DiffcalcException(
                "One reflection is required to calculate a u matrix")

        h = matrix([h]).T  # row->column
        pos.changeToRadians()
        B = self._state.crystal.B
        h_crystal = B * h
        h_crystal = h_crystal * (1 / norm(h_crystal))

        q_measured_phi = self._strategy.calculate_q_phi(pos)
        q_measured_phi = q_measured_phi * (1 / norm(q_measured_phi))

        rotation_axis = cross3(h_crystal, q_measured_phi)
        rotation_axis = rotation_axis * (1 / norm(rotation_axis))

        cos_rotation_angle = dot3(h_crystal, q_measured_phi)
        rotation_angle = acos(cos_rotation_angle)

        uvw = rotation_axis.T.tolist()[0]  # TODO: cleanup
        print "resulting U angle: %.5f deg" % (rotation_angle * TODEG)
        u_repr = (', '.join(['% .5f' % el for el in uvw]))
        print "resulting U axis direction: [%s]" % u_repr

        u, v, w = uvw
        rcos = cos(rotation_angle)
        rsin = sin(rotation_angle)
        m = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]  # TODO: tidy
        m[0][0] = rcos + u * u * (1 - rcos)
        m[1][0] = w * rsin + v * u * (1 - rcos)
        m[2][0] = -v * rsin + w * u * (1 - rcos)
        m[0][1] = -w * rsin + u * v * (1 - rcos)
        m[1][1] = rcos + v * v * (1 - rcos)
        m[2][1] = u * rsin + w * v * (1 - rcos)
        m[0][2] = v * rsin + u * w * (1 - rcos)
        m[1][2] = -u * rsin + v * w * (1 - rcos)
        m[2][2] = rcos + w * w * (1 - rcos)

        if self._UB is None:
            print "Calculating UB matrix from the first reflection only."
        else:
            print "Recalculating UB matrix from the first reflection only."
        print(
            "NOTE: A new UB matrix will not be automatically calculated "
            "when the orientation reflections are modified.")

        self._state.configure_calc_type(or0=1)

        self._U = matrix(m)
        self._UB = self._U * B

        self.save()

    def get_hkl_plane_distance(self, hkl):
        """Calculates and returns the distance between planes"""
        return self._state.crystal.get_hkl_plane_distance(hkl)
예제 #6
0
파일: calc.py 프로젝트: robwalton/diffcalc
class UBCalculation:
    """A UB matrix calculation for an experiment.

    Contains the parameters for the _crystal under test, a list of measured
    reflections and, if its been calculated, a UB matrix to be used by the rest
    of the code.
    """

    def __init__(self, diffractometer_axes_names, diffractometerPluginObject, persister, strategy, include_sigtau=True):

        # The diffractometer geometry is required to map the internal angles
        # into those used by this diffractometer (for display only)

        self._diffractometer_axes_names = diffractometer_axes_names
        self._geometry = diffractometerPluginObject
        self._persister = persister
        self._strategy = strategy
        self._include_sigtau = include_sigtau
        self.reference = YouReference(self)  # TODO: move into _state and persist
        self._clear()

    def _clear(self, name=None):
        # NOTE the Diffraction calculator is expecting this object to exist in
        # the long run. We can't remove this entire object, and recreate it.
        # It also contains a required link to the angle calculator.
        reflist = ReflectionList(self._geometry, self._diffractometer_axes_names)
        self._state = UBCalcState(name=name, reflist=reflist)
        self._U = None
        self._UB = None
        self._state.configure_calc_type()

    ### State ###
    def start_new(self, name):
        """start_new(name) --- creates a new blank ub calculation"""
        # Create storage object if name does not exist (TODO)
        if name in self._persister.list():
            print ("No UBCalculation started: There is already a calculation " "called: " + name)
            print "Saved calculations: " + repr(self._persister.list())
            return
        self._clear(name)
        self.save()

    def load(self, name):
        state = self._persister.load(name)
        self._state = decode_ubcalcstate(state, self._geometry, self._diffractometer_axes_names)
        if self._state.manual_U is not None:
            self.set_U_manually(self._state.manual_U)
        elif self._state.manual_UB is not None:
            self.set_UB_manually(self._state.manual_UB)
        elif self._state.or0 is not None:
            if self._state.or1 is None:
                self.calculate_UB_from_primary_only()
            else:
                self.calculate_UB()
        else:
            pass

    def save(self):
        self.saveas(self._state.name)

    def saveas(self, name):
        self._state.name = name
        self._persister.save(self._state, name)

    def listub(self):
        return self._persister.list()

    def remove(self, name):
        self._persister.remove(name)

    def getState(self):
        return self._state.getState()

    def __str__(self):
        WIDTH = 13

        if self._state.name is None:
            return "<<< No UB calculation started >>>"
        lines = []
        lines.append("UBCALC")
        lines.append("")
        lines.append("   name:".ljust(WIDTH) + self._state.name.rjust(9))
        if self._include_sigtau:
            lines.append("   sigma:".ljust(WIDTH) + ("% 9.5f" % self._state.sigma).rjust(9))
            lines.append("   tau:".ljust(WIDTH) + ("% 9.5f" % self._state.tau).rjust(9))

        lines.append("")
        lines.append("CRYSTAL")
        lines.append("")
        if self._state.crystal is None:
            lines.append("   <<< none specified >>>")
        else:
            lines.extend(self._state.crystal.str_lines())

        lines.append("")
        lines.append("UB MATRIX")
        lines.append("")
        if self._UB is None:
            lines.append("   <<< none calculated >>>")
        else:
            fmt = "% 9.5f % 9.5f % 9.5f"
            U = self.U
            UB = self.UB
            lines.append("   U matrix:".ljust(WIDTH) + fmt % (U[0, 0], U[0, 1], U[0, 2]))
            lines.append(" " * WIDTH + fmt % (U[1, 0], U[1, 1], U[1, 2]))
            lines.append(" " * WIDTH + fmt % (U[2, 0], U[2, 1], U[2, 2]))
            lines.append("")

            lines.append("   UB matrix:".ljust(WIDTH) + fmt % (UB[0, 0], UB[0, 1], UB[0, 2]))
            lines.append(" " * WIDTH + fmt % (UB[1, 0], UB[1, 1], UB[1, 2]))
            lines.append(" " * WIDTH + fmt % (UB[2, 0], UB[2, 1], UB[2, 2]))

        lines.append("")
        lines.append("REFLECTIONS")
        lines.append("")
        lines.extend(self._state.reflist.str_lines())
        return "\n".join(lines)

    @property
    def name(self):
        return self._state.name

    ### Lattice ###

    def set_lattice(self, name, *shortform):
        """
        Converts a list shortform crystal parameter specification to a six-long
        tuple returned as . Returns None if wrong number of input args. See
        set_lattice() for a description of the shortforms supported.

        shortformLattice -- a tuple as follows:
             [a]         - assumes cubic
           [a,b])       - assumes tetragonal
           [a,b,c])     - assumes ortho
           [a,b,c,gam]) - assumes mon/hex gam different from 90.
           [a,b,c,alp,bet,gam]) - for arbitrary
           where all measurements in angstroms and angles in degrees
        """
        self._set_lattice_without_saving(name, *shortform)
        self.save()

    def _set_lattice_without_saving(self, name, *shortform):
        sf = shortform
        if len(sf) == 1:
            fullform = (sf[0], sf[0], sf[0], 90.0, 90.0, 90.0)  # cubic
        elif len(sf) == 2:
            fullform = (sf[0], sf[0], sf[1], 90.0, 90.0, 90.0)  # tetragonal
        elif len(sf) == 3:
            fullform = (sf[0], sf[1], sf[2], 90.0, 90.0, 90.0)  # ortho
        elif len(sf) == 4:
            fullform = (sf[0], sf[1], sf[2], 90.0, 90.0, sf[3])  # mon/hex gam
            # not 90
        elif len(sf) == 5:
            raise ValueError("wrong length input to set_lattice")
        elif len(sf) == 6:
            fullform = sf  # triclinic/arbitrary
        else:
            raise ValueError("wrong length input to set_lattice")
        self._set_lattice(name, *fullform)

    def _set_lattice(self, name, a, b, c, alpha, beta, gamma):
        """set lattice parameters in degrees"""
        if self._state.name is None:
            raise DiffcalcException("Cannot set lattice until a UBCalcaluation has been started " "with newubcalc")
        self._state.crystal = CrystalUnderTest(name, a, b, c, alpha, beta, gamma)
        # Clear U and UB if these exist
        if self._U != None:  # (UB will also exist)
            self._U = None
            self._UB = None
            print "Warning: the old UB calculation has been cleared."
            print "         Use 'calcub' to recalculate with old reflections."

    ### Surface normal stuff ###

    def _gettau(self):
        """
        Returns tau (in degrees): the (minus) ammount of phi axis rotation ,
        that together with some chi axis rotation (minus sigma) brings the
        optical surface normal parallelto the omega axis.
        """
        return self._state.tau

    def _settau(self, tau):
        self._state.tau = tau
        self.save()

    tau = property(_gettau, _settau)

    def _getsigma(self):
        """
        Returns sigma (in degrees): the (minus) ammount of phi axis rotation ,
        that together with some phi axis rotation (minus tau) brings the
        optical surface normal parallelto the omega axis.
        """
        return self._state.sigma

    def _setsigma(self, sigma):
        self.state._sigma = sigma
        self.save()

    sigma = property(_getsigma, _setsigma)

    ### Reflections ###

    def add_reflection(self, h, k, l, position, energy, tag, time):
        """add_reflection(h, k, l, position, tag=None) -- adds a reflection

        position is in degrees and in the systems internal representation.
        """
        if self._state.reflist is None:
            raise DiffcalcException("No UBCalculation loaded")
        self._state.reflist.add_reflection(h, k, l, position, energy, tag, time)
        self.save()  # incase autocalculateUbAndReport fails

        # If second reflection has just been added then calculateUB
        if len(self._state.reflist) == 2:
            self._autocalculateUbAndReport()
        self.save()

    def edit_reflection(self, num, h, k, l, position, energy, tag, time):
        """
        edit_reflection(num, h, k, l, position, tag=None) -- adds a reflection

        position is in degrees and in the systems internal representation.
        """
        if self._state.reflist is None:
            raise DiffcalcException("No UBCalculation loaded")
        self._state.reflist.edit_reflection(num, h, k, l, position, energy, tag, time)

        # If first or second reflection has been changed and there are at least
        # two reflections then recalculate  UB
        if (num == 1 or num == 2) and len(self._state.reflist) >= 2:
            self._autocalculateUbAndReport()
        self.save()

    def get_reflection(self, num):
        """--> ( [h, k, l], position, energy, tag, time
        num starts at 1, position in degrees"""
        return self._state.reflist.getReflection(num)

    def get_reflection_in_external_angles(self, num):
        """--> ( [h, k, l], position, energy, tag, time
        num starts at 1, position in degrees"""
        return self._state.reflist.get_reflection_in_external_angles(num)

    def get_number_reflections(self):
        return 0 if self._state.reflist is None else len(self._state.reflist)

    def del_reflection(self, reflectionNumber):
        self._state.reflist.removeReflection(reflectionNumber)
        if (reflectionNumber == 1 or reflectionNumber == 2) and (self._U != None):
            self._autocalculateUbAndReport()
        self.save()

    def swap_reflections(self, num1, num2):
        self._state.reflist.swap_reflections(num1, num2)
        if (num1 == 1 or num1 == 2 or num2 == 1 or num2 == 2) and (self._U != None):
            self._autocalculateUbAndReport()
        self.save()

    def _autocalculateUbAndReport(self):
        if len(self._state.reflist) < 2:
            pass
        elif self._state.crystal is None:
            print ("Not calculating UB matrix as no lattice parameters have " "been specified.")
        elif not self._state.is_okay_to_autocalculate_ub:
            print (
                "Not calculating UB matrix as it has been manually set. " "Use 'calcub' to explicitly recalculate it."
            )
        else:  # okay to autocalculate
            if self._UB is None:
                print "Calculating UB matrix."
            else:
                print "Recalculating UB matrix."
            self.calculate_UB()

    #    @property
    #    def reflist(self):
    #        return self._state.reflist
    ### Calculations ###

    def set_U_manually(self, m):
        """Manually sets U. matrix must be 3*3 Jama or python matrix.
        Turns off aution UB calcualtion."""

        # Check matrix is a 3*3 Jama matrix
        if m.__class__ != matrix:
            m = matrix(m)  # assume its a python matrix
        if m.shape[0] != 3 or m.shape[1] != 3:
            raise ValueError("Expects 3*3 matrix")

        if self._UB is None:
            print "Calculating UB matrix."
        else:
            print "Recalculating UB matrix."

        self._state.configure_calc_type(manual_U=m)
        self._U = m
        if self._state.crystal is None:
            raise DiffcalcException("A crystal must be specified before manually setting U")
        self._UB = self._U * self._state.crystal.B
        print (
            "NOTE: A new UB matrix will not be automatically calculated "
            "when the orientation reflections are modified."
        )
        self.save()

    def set_UB_manually(self, m):
        """Manually sets UB. matrix must be 3*3 Jama or python matrix.
        Turns off aution UB calcualtion."""

        # Check matrix is a 3*3 Jama matrix
        if m.__class__ != matrix:
            m = matrix(m)  # assume its a python matrix
        if m.shape[0] != 3 or m.shape[1] != 3:
            raise ValueError("Expects 3*3 matrix")

        self._state.configure_calc_type(manual_UB=m)
        self._UB = m
        self.save()

    @property
    def U(self):
        if self._U is None:
            raise DiffcalcException("No U matrix has been calculated during this ub calculation")
        return self._U

    @property
    def UB(self):
        if self._UB is None:
            raise DiffcalcException("No UB matrix has been calculated during this ub calculation")
        else:
            return self._UB

    def calculate_UB(self):
        """
        Calculate orientation matrix. Uses first two orientation reflections
        as in Busang and Levy, but for the diffractometer in Lohmeier and
        Vlieg.
        """

        # Major variables:
        # h1, h2: user input reciprical lattice vectors of the two reflections
        # h1c, h2c: user input vectors in cartesian crystal plane
        # pos1, pos2: measured diffractometer positions of the two reflections
        # u1a, u2a: measured reflection vectors in alpha frame
        # u1p, u2p: measured reflection vectors in phi frame

        # Get hkl and angle values for the first two refelctions
        if self._state.reflist is None:
            raise DiffcalcException(
                "Cannot calculate a U matrix until a " "UBCalculation has been started with " "'newub'"
            )
        try:
            (h1, pos1, _, _, _) = self._state.reflist.getReflection(1)
            (h2, pos2, _, _, _) = self._state.reflist.getReflection(2)
        except IndexError:
            raise DiffcalcException("Two reflections are required to calculate a u matrix")
        h1 = matrix([h1]).T  # row->column
        h2 = matrix([h2]).T
        pos1.changeToRadians()
        pos2.changeToRadians()

        # Compute the two reflections' reciprical lattice vectors in the
        # cartesian crystal frame
        B = self._state.crystal.B
        h1c = B * h1
        h2c = B * h2

        u1p = self._strategy.calculate_q_phi(pos1)
        u2p = self._strategy.calculate_q_phi(pos2)

        # Create modified unit vectors t1, t2 and t3 in crystal and phi systems
        t1c = h1c
        t3c = cross3(h1c, h2c)
        t2c = cross3(t3c, t1c)

        t1p = u1p  # FIXED from h1c 9July08
        t3p = cross3(u1p, u2p)
        t2p = cross3(t3p, t1p)

        # ...and nornmalise and check that the reflections used are appropriate
        SMALL = 1e-4  # Taken from Vlieg's code
        e = DiffcalcException("Invalid orientation reflection(s)")

        def normalise(m):
            d = norm(m)
            if d < SMALL:
                raise e
            return m / d

        t1c = normalise(t1c)
        t2c = normalise(t2c)
        t3c = normalise(t3c)

        t1p = normalise(t1p)
        t2p = normalise(t2p)
        t3p = normalise(t3p)

        Tc = hstack([t1c, t2c, t3c])
        Tp = hstack([t1p, t2p, t3p])
        self._state.configure_calc_type(or0=1, or1=2)
        self._U = Tp * Tc.I
        self._UB = self._U * B
        self.save()

    def calculate_UB_from_primary_only(self):
        """
        Calculate orientation matrix with the shortest absolute angle change.
        Uses first orientation reflection
        """

        # Algorithm from http://www.j3d.org/matrix_faq/matrfaq_latest.html

        # Get hkl and angle values for the first two refelctions
        if self._state.reflist is None:
            raise DiffcalcException("Cannot calculate a u matrix until a UBCalcaluation has been " "started with newub")
        try:
            (h, pos, _, _, _) = self._state.reflist.getReflection(1)
        except IndexError:
            raise DiffcalcException("One reflection is required to calculate a u matrix")

        h = matrix([h]).T  # row->column
        pos.changeToRadians()
        B = self._state.crystal.B
        h_crystal = B * h
        h_crystal = h_crystal * (1 / norm(h_crystal))

        q_measured_phi = self._strategy.calculate_q_phi(pos)
        q_measured_phi = q_measured_phi * (1 / norm(q_measured_phi))

        rotation_axis = cross3(h_crystal, q_measured_phi)
        rotation_axis = rotation_axis * (1 / norm(rotation_axis))

        cos_rotation_angle = dot3(h_crystal, q_measured_phi)
        rotation_angle = acos(cos_rotation_angle)

        uvw = rotation_axis.T.tolist()[0]  # TODO: cleanup
        print "resulting U angle: %.5f deg" % (rotation_angle * TODEG)
        u_repr = ", ".join(["% .5f" % el for el in uvw])
        print "resulting U axis direction: [%s]" % u_repr

        u, v, w = uvw
        rcos = cos(rotation_angle)
        rsin = sin(rotation_angle)
        m = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]  # TODO: tidy
        m[0][0] = rcos + u * u * (1 - rcos)
        m[1][0] = w * rsin + v * u * (1 - rcos)
        m[2][0] = -v * rsin + w * u * (1 - rcos)
        m[0][1] = -w * rsin + u * v * (1 - rcos)
        m[1][1] = rcos + v * v * (1 - rcos)
        m[2][1] = u * rsin + w * v * (1 - rcos)
        m[0][2] = v * rsin + u * w * (1 - rcos)
        m[1][2] = -u * rsin + v * w * (1 - rcos)
        m[2][2] = rcos + w * w * (1 - rcos)

        if self._UB is None:
            print "Calculating UB matrix from the first reflection only."
        else:
            print "Recalculating UB matrix from the first reflection only."
        print (
            "NOTE: A new UB matrix will not be automatically calculated "
            "when the orientation reflections are modified."
        )

        self._state.configure_calc_type(or0=1)

        self._U = matrix(m)
        self._UB = self._U * B

        self.save()

    def get_hkl_plane_distance(self, hkl):
        """Calculates and returns the distance between planes"""
        return self._state.crystal.get_hkl_plane_distance(hkl)
예제 #7
0
class UBCalculation:
    """A UB matrix calculation for an experiment.

    Contains the parameters for the _crystal under test, a list of measured
    reflections and, if its been calculated, a UB matrix to be used by the rest
    of the code.
    """
    def __init__(self,
                 persister,
                 strategy,
                 include_sigtau=True,
                 include_reference=True):

        # The diffractometer geometry is required to map the internal angles
        # into those used by this diffractometer (for display only)

        self._persister = persister
        self._strategy = strategy
        self.include_sigtau = include_sigtau
        self.include_reference = include_reference
        try:
            self._tobj = CoordinateConverter(
                transform=settings.geometry.beamline_axes_transform)
        except AttributeError:
            self._tobj = CoordinateConverter(transform=None)
        self._clear()

    def _get_diffractometer_axes_names(self):
        return settings.hardware.get_axes_names()

    def _clear(self, name=None):
        # NOTE the Diffraction calculator is expecting this object to exist in
        # the long run. We can't remove this entire object, and recreate it.
        # It also contains a required link to the angle calculator.
        reflist = ReflectionList(
            settings.geometry,
            self._get_diffractometer_axes_names(),
            multiplier=settings.hardware.energyScannableMultiplierToGetKeV)
        orientlist = OrientationList(settings.geometry,
                                     self._get_diffractometer_axes_names())
        reference = YouReference(self._get_UB)
        reference._set_n_hkl_configured(settings.reference_vector)
        surface = YouReference(self._get_UB)
        surface._set_n_phi_configured(settings.surface_vector)
        self._state = UBCalcState(name=name,
                                  reflist=reflist,
                                  orientlist=orientlist,
                                  reference=reference,
                                  surface=surface)
        self._U = None
        self._UB = None
        self._state.configure_calc_type()

### State ###

    def start_new(self, name):
        """Start new UB matrix calculation.
        
        Creates a new blank UB matrix calculation.
        
        Parameters
        ----------
        name: str
            Name of a new UB matrix calculation
        """
        # Create storage object if name does not exist (TODO)
        self._clear(name)
        self.save()

    def load(self, name):
        state = self._persister.load(name)
        if isinstance(self._persister, UBCalculationJSONPersister):
            self._state = self._persister.encoder.decode_ubcalcstate(
                state, settings.geometry,
                self._get_diffractometer_axes_names(),
                settings.hardware.energyScannableMultiplierToGetKeV)
            self._state.reference.get_UB = self._get_UB
            self._state.surface.get_UB = self._get_UB
        elif isinstance(self._persister, UBCalculationPersister):
            self._state = state
        else:
            raise DiffcalcException('Unexpected persister type: ' +
                                    str(self._persister))
        if self._state.manual_U is not None:
            self._U = self._state.manual_U
            self._UB = self._U * self._state.crystal.B
            self.save()
        elif self._state.manual_UB is not None:
            self._UB = self._state.manual_UB
            self.save()
        elif self._state.is_okay_to_autocalculate_ub:
            try:
                self.calculate_UB(self._state.or0, self._state.or1)
            except Exception as e:
                print(e)
        else:
            print("Warning: No UB calculation loaded.")

    def save(self):
        """Save current UB matrix calculation."""
        if self._state.name:
            self.saveas(self._state.name)
        else:
            print("Warning: No UB calculation defined.")

    def saveas(self, name):
        """Save current UB matrix calculation.
        
        Parameters
        ----------
        name : str
            Name for the saved UB matrix calculation.
        """
        self._state.name = name
        self._persister.save(self._state, name)

    def listub(self):
        """List saved UB matrix calculations.
        
        Returns:
        :obj:`list` of :obj:`str`
            List of names of the saved UB matrix calculations.
        """
        return self._persister.list()

    def listub_metadata(self):
        return self._persister.list_metadata()

    def remove(self, name):
        """Delete UB matrix calculation.
        
        Parameters
        ----------
        name : str
            Name of the UB matrix calculation to be deleted.
        """
        self._persister.remove(name)
        if self._state.name == name:
            self._clear()

    def getState(self):
        return self._state.getState()

    def __str__(self):

        if self._state.name is None:
            return "<<< No UB calculation started >>>"
        lines = []
        lines.append(bold("UBCALC"))
        lines.append("")
        lines.append("   name:".ljust(WIDTH) + self._state.name.rjust(9))

        if self.include_sigtau:
            lines.append("")
            lines.append("   sigma:".ljust(WIDTH) +
                         ("% 9.5f" % self._state.sigma).rjust(9))
            lines.append("   tau:".ljust(WIDTH) +
                         ("% 9.5f" % self._state.tau).rjust(9))

        _ub_calculated = self._UB is not None
        if self.include_reference:
            lines.append("")
            lines.append(bold("REFERNCE"))
            lines.append("")
            lines.extend(
                self._state.reference.repr_lines(_ub_calculated, WIDTH,
                                                 self._tobj))
        lines.append("")
        lines.append(bold("SURFACE NORMAL"))
        lines.append("")
        lines.extend(
            self._state.surface.repr_lines(_ub_calculated, WIDTH, self._tobj))

        lines.append("")
        lines.append(bold("CRYSTAL"))
        lines.append("")

        if self._state.crystal is None:
            lines.append("   <<< none specified >>>")
        else:
            lines.extend(self._state.crystal.str_lines(self._tobj))

        lines.append("")
        lines.append(bold("UB MATRIX"))
        lines.append("")

        if self._UB is None:
            lines.append("   <<< none calculated >>>")
        else:
            lines.extend(self.str_lines_u(self.U))
            lines.append("")
            lines.extend(self.str_lines_ub_angle_and_axis(self.UB))
            lines.append("")
            lines.extend(self.str_lines_ub(self.UB))

        lines.extend(self.str_lines_refl())

        lines.extend(self.str_lines_orient())

        return '\n'.join(lines)

    def str_lines_u(self, umatrix):
        lines = []
        fmt = "% 9.5f % 9.5f % 9.5f"
        U = self._tobj.transform(umatrix, True)
        lines.append("   U matrix:".ljust(WIDTH) + fmt %
                     (z(U[0, 0]), z(U[0, 1]), z(U[0, 2])))
        lines.append(' ' * WIDTH + fmt % (z(U[1, 0]), z(U[1, 1]), z(U[1, 2])))
        lines.append(' ' * WIDTH + fmt % (z(U[2, 0]), z(U[2, 1]), z(U[2, 2])))
        return lines

    def str_lines_ub_angle_and_axis(self, ubmatrix):
        lines = []
        fmt = "% 9.5f % 9.5f % 9.5f"
        rotation_angle, rotation_axis = self.get_miscut_angle_axis(ubmatrix)
        if abs(norm(rotation_axis)) < SMALL:
            lines.append("   miscut angle:".ljust(WIDTH) + "  0")
        else:
            lines.append("   miscut:")
            lines.append("      angle:".ljust(WIDTH) +
                         "% 9.5f" % rotation_angle)
            lines.append("       axis:".ljust(WIDTH) +
                         fmt % tuple((rotation_axis.T).tolist()[0]))

        return lines

    def str_lines_ub(self, ubmatrix):
        lines = []
        fmt = "% 9.5f % 9.5f % 9.5f"
        if self._tobj.R is not None:
            UB = self._tobj.R.I * ubmatrix
        else:
            UB = self.UB
        lines.append("   UB matrix:".ljust(WIDTH) + fmt %
                     (z(UB[0, 0]), z(UB[0, 1]), z(UB[0, 2])))
        lines.append(' ' * WIDTH + fmt %
                     (z(UB[1, 0]), z(UB[1, 1]), z(UB[1, 2])))
        lines.append(' ' * WIDTH + fmt %
                     (z(UB[2, 0]), z(UB[2, 1]), z(UB[2, 2])))
        return lines

    def str_lines_refl(self):
        lines = ["", bold("REFLECTIONS"), ""]

        lines.extend(self._state.reflist.str_lines())
        return lines

    def str_lines_orient(self):
        lines = ["", bold("CRYSTAL ORIENTATIONS"), ""]

        lines.extend(self._state.orientlist.str_lines(self._tobj))
        return lines

    @property
    def name(self):
        """str: Name of the current UB matrix calculation."""
        return self._state.name
### Lattice ###

    def set_lattice(self, name, *shortform):
        """
        Converts a list shortform crystal parameter specification to a six-long
        tuple. See setlat() for a description of the shortforms supported.
        """
        if not shortform:
            raise TypeError("Please specify unit cell parameters.")
        elif allnum(shortform):
            sf = shortform
            if len(sf) == 1:
                system = "Cubic"
            elif len(sf) == 2:
                system = "Tetragonal"
            elif len(sf) == 3:
                system = "Orthorhombic"
            elif len(sf) == 4:
                if abs(sf[0] - sf[1]) < SMALL and sf[3] == 120:
                    system = "Hexagonal"
                else:
                    system = "Monoclinic"
            elif len(sf) == 6:
                system = "Triclinic"
            else:
                raise TypeError(
                    "Invalid number of input parameters to set unit lattice.")
            fullform = (system, ) + shortform
        else:
            if not isinstance(shortform[0], str):
                raise TypeError("Invalid unit cell parameters specified.")
            fullform = shortform
        if self._state.name is None:
            raise DiffcalcException(
                "Cannot set lattice until a UBCalcaluation has been started "
                "with newubcalc")
        self._state.crystal = CrystalUnderTest(name, *fullform)
        # Clear U and UB if these exist
        if self._U is not None:  # (UB will also exist)
            print("Warning: Setting new unit cell parameters.\n"
                  "         The old UB calculation has been cleared.")
        self.save()

### Surface normal stuff ###

    def _gettau(self):
        """
        Returns tau (in degrees): the (minus) ammount of phi axis rotation ,
        that together with some chi axis rotation (minus sigma) brings the
        optical surface normal parallel to the omega axis.
        """
        return self._state.tau

    def _settau(self, tau):
        self._state.tau = tau
        self.save()

    tau = property(_gettau, _settau)

    def _getsigma(self):
        """
        Returns sigma (in degrees): the (minus) ammount of phi axis rotation ,
        that together with some phi axis rotation (minus tau) brings the
        optical surface normal parallel to the omega axis.
        """
        return self._state.sigma

    def _setsigma(self, sigma):
        self.state._sigma = sigma
        self.save()

    sigma = property(_getsigma, _setsigma)

    ### Reference vector ###

    def _get_n_hkl(self):
        return self._state.reference.n_hkl

    def _get_n_phi(self):
        return self._state.reference.n_phi

    n_hkl = property(_get_n_hkl)
    n_phi = property(_get_n_phi)

    def set_n_phi_configured(self, n_phi):
        self._state.reference.n_phi_configured = self._tobj.transform(n_phi)
        self.save()

    def set_n_hkl_configured(self, n_hkl):
        self._state.reference.n_hkl_configured = n_hkl
        self.save()

    def print_reference(self):
        print('\n'.join(
            self._state.reference.repr_lines(self.is_ub_calculated(),
                                             WIDTH=9,
                                             conv=self._tobj)))

### Surface vector ###

    def _get_surf_nhkl(self):
        return self._state.surface.n_hkl

    def _get_surf_nphi(self):
        return self._state.surface.n_phi

    surf_nhkl = property(_get_surf_nhkl)
    surf_nphi = property(_get_surf_nphi)

    def set_surf_nphi_configured(self, n_phi):
        self._state.surface.n_phi_configured = self._tobj.transform(n_phi)
        self.save()

    def set_surf_nhkl_configured(self, n_hkl):
        self._state.surface.n_hkl_configured = n_hkl
        self.save()

    def print_surface(self):
        print('\n'.join(
            self._state.surface.repr_lines(self.is_ub_calculated(),
                                           WIDTH=9,
                                           conv=self._tobj)))

### Reflections ###

    def add_reflection(self, h, k, l, position, energy, tag, time):
        """Add a reference reflection.
        
        Adds a reflection position in degrees and in the
        systems internal representation.
        
        Parameters
        ----------
        h : number
            h index of the reflection
        k : number
            k index of the reflection
        l : number
            l index of the reflection
        position: :obj:`list` or :obj:`tuple` of numbers
            list of diffractometer angles in internal representation in degrees
        energy : float
            energy of the x-ray beam
        tag : str
            identifying tag for the reflection
        time : :obj:`datetime`
            datetime object
        """
        if self._state.reflist is None:
            raise DiffcalcException("No UBCalculation loaded")
        self._state.reflist.add_reflection(h, k, l, position, energy, tag,
                                           time)
        self.save()  # incase autocalculateUbAndReport fails

        # If second reflection has just been added then calculateUB
        if self.get_reference_count() == 2:
            self._autocalculateUbAndReport()
        self.save()

    def edit_reflection(self, idx, h, k, l, position, energy, tag, time):
        """Changes a reference reflection.
        
        Changes a reflection position in degrees and in the
        systems internal representation.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the reflection to be changed
        h : number
            h index of the reflection
        k : number
            k index of the reflection
        l : number
            l index of the reflection
        position: :obj:`list` or :obj:`tuple` of numbers
            list of diffractometer angles in internal representation in degrees
        energy : float
            energy of the x-ray beam
        tag : str
            identifying tag for the reflection
        time : :obj:`datetime`
            datetime object
        """
        if self._state.reflist is None:
            raise DiffcalcException("No UBCalculation loaded")
        num = self.get_tag_refl_num(idx)
        self._state.reflist.edit_reflection(num, h, k, l, position, energy,
                                            tag, time)

        # If first or second reflection has been changed and there are at least
        # two reflections then recalculate  UB
        or12 = self.get_ub_references()
        if idx in or12 or num in or12:
            self._autocalculateUbAndReport()
        self.save()

    def get_reflection(self, idx):
        """Get a reference reflection.
        
        Get a reflection position in degrees and in the
        systems internal representation.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the reflection
        """
        return self._state.reflist.getReflection(idx)

    def get_reflection_in_external_angles(self, idx):
        """Get a reference reflection.
        
        Get a reflection position in degrees and in the
        external diffractometer representation.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the reflection
        """
        return self._state.reflist.get_reflection_in_external_angles(idx)

    def get_number_reflections(self):
        """Get a number of stored reference reflections.
        
        Returns
        -------
        int:
            Number of reference reflections.
        """
        try:
            return len(self._state.reflist)
        except TypeError:
            return 0

    def get_tag_refl_num(self, tag):
        """Get a reference reflection index.
        
        Get a reference reflection index for the 
        provided reflection tag.
        
        Parameters
        ----------
        tag : str
            identifying tag for the reflection
        Returns
        -------
        int:
            Reference reflection index
        """
        if tag is None:
            raise IndexError("Reflection tag is None")
        return self._state.reflist.get_tag_index(tag) + 1

    def del_reflection(self, idx):
        """Delete a reference reflection.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the deleted reflection
        """
        num = self.get_tag_refl_num(idx)
        self._state.reflist.removeReflection(num)
        or12 = self.get_ub_references()
        if ((idx in or12 or num in or12) and (self._U is not None)):
            self._autocalculateUbAndReport()
        self.save()

    def swap_reflections(self, idx1, idx2):
        """Swap indices of two reference reflections.
        
        Parameters
        ----------
        idx1 : str or int
            index or tag of the first reflection to be swapped
        idx2 : str or int
            index or tag of the second reflection to be swapped
        """
        num1 = self.get_tag_refl_num(idx1)
        num2 = self.get_tag_refl_num(idx2)
        self._state.reflist.swap_reflections(num1, num2)
        or12 = self.get_ub_references()
        if ((idx1 in or12 or idx2 in or12 or num1 in or12 or num2 in or12)
                and (self._U is not None)):
            self._autocalculateUbAndReport()
        self.save()

    def _autocalculateUbAndReport(self):
        if self.get_reference_count() < 2:
            pass
        elif self._state.crystal is None:
            print("Not calculating UB matrix as no lattice parameters have "
                  "been specified.")
        elif not self._state.is_okay_to_autocalculate_ub:
            print("Not calculating UB matrix as it has been manually set. "
                  "Use 'calcub' to explicitly recalculate it.")
        else:  # okay to autocalculate
            if self._UB is None:
                print("Calculating UB matrix.")
            else:
                print("Recalculating UB matrix.")
            or12 = self.get_ub_references()
            self.calculate_UB(*or12)

### Orientations ###

    def add_orientation(self, h, k, l, x, y, z, position, tag, time):
        """Add a reference orientation.
        
        Adds a reference orientation in the external diffractometer
        coordinate system.
        
        Parameters
        ----------
        h : number
            h index of the reference orientation
        k : number
            k index of the reference orientation
        l : number
            l index of the reference orientation
        x : number
            x coordinate of the reference orientation
        y : number
            x coordinate of the reference orientation
        z : number
            x coordinate of the reference orientation
        position: :obj:`list` or :obj:`tuple` of numbers
            list of diffractometer angles in internal representation in degrees
        tag : str
            identifying tag for the reflection
        time : :obj:`datetime`
            datetime object
        """
        if self._state.orientlist is None:
            raise DiffcalcException("No UBCalculation loaded")
        xyz_tr = self._tobj.transform(matrix([[x], [y], [z]]))
        xr, yr, zr = xyz_tr.T.tolist()[0]
        self._state.orientlist.add_orientation(h, k, l, xr, yr, zr, position,
                                               tag, time)
        self.save()  # in case autocalculateUbAndReport fails

        # If second reflection has just been added then calculateUB
        if self.get_reference_count() == 2:
            self._autocalculateUbAndReport()
        self.save()

    def edit_orientation(self, idx, h, k, l, x, y, z, position, tag, time):
        """Change a reference orientation.
        
        Changes a reference orientation in the external diffractometer
        coordinate system.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the orientation to be changed
        h : number
            h index of the reference orientation
        k : number
            k index of the reference orientation
        l : number
            l index of the reference orientation
        x : number
            x coordinate of the reference orientation
        y : number
            x coordinate of the reference orientation
        z : number
            x coordinate of the reference orientation
        position: :obj:`list` or :obj:`tuple` of numbers
            list of diffractometer angles in internal representation in degrees
        tag : str
            identifying tag for the reflection
        time : :obj:`datetime`
            datetime object
        """
        if self._state.orientlist is None:
            raise DiffcalcException("No UBCalculation loaded")
        num = self.get_tag_orient_num(idx)
        xyz_tr = self._tobj.transform(matrix([[x], [y], [z]]))
        xr, yr, zr = xyz_tr.T.tolist()[0]
        self._state.orientlist.edit_orientation(num, h, k, l, xr, yr, zr,
                                                position, tag, time)

        # If first or second orientation has been changed and there are
        # two orientations then recalculate  UB
        or12 = self.get_ub_references()
        if idx in or12 or num in or12:
            self._autocalculateUbAndReport()
        self.save()

    def get_orientation(self, idx, conv=False):
        """Get a reference orientation.
        
        Get a reference orientation in the external diffractometer
        coordinate system.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the reference orientation
        """
        hkl, xyz, pos, tg, tm = self._state.orientlist.getOrientation(idx)
        if conv:
            xyz_rot = self._tobj.transform(
                matrix([[xyz[0]], [xyz[1]], [xyz[2]]]), True)
            xyz = xyz_rot.T.tolist()[0]
        return hkl, xyz, pos, tg, tm

    def get_orientation_in_external_angles(self, idx, conv=False):
        """Get a reference orientation.
        
        Get a reference orientation in the external diffractometer
        coordinate system with diffractometer position in external angles.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the reference orientation
        """
        hkl, xyz, pos, tg, tm = self._state.orientlist.get_orientation_in_external_angles(
            idx)
        if conv:
            xyz_rot = self._tobj.transform(
                matrix([[xyz[0]], [xyz[1]], [xyz[2]]]), True)
            xyz = xyz_rot.T.tolist()[0]
        return hkl, xyz, pos, tg, tm

    def get_number_orientations(self):
        """Get a number of stored reference orientations.
        
        Returns
        -------
        int:
            Number of reference orientations.
        """
        try:
            return len(self._state.orientlist)
        except TypeError:
            return 0

    def get_tag_orient_num(self, tag):
        """Get a reference orientation index.
        
        Get a reference orientation index for the 
        provided orientation tag.
        
        Parameters
        ----------
        tag : str
            identifying tag for the orientation
        Returns
        -------
        int:
            Reference orientation index
        """
        if tag is None:
            raise IndexError("Orientations tag is None")
        return self._state.orientlist.get_tag_index(tag) + 1

    def del_orientation(self, idx):
        """Delete a reference orientation.
        
        Parameters
        ----------
        idx : str or int
            index or tag of the deleted orientation
        """
        orientationNumber = self.get_tag_orient_num(idx)
        self._state.orientlist.removeOrientation(orientationNumber)
        if ((orientationNumber == 2) and (self._U is not None)):
            self._autocalculateUbAndReport()
        self.save()

    def swap_orientations(self, idx1, idx2):
        """Swap indices of two reference orientations.
        
        Parameters
        ----------
        idx1 : str or int
            index or tag of the first orientation to be swapped
        idx2 : str or int
            index or tag of the second orientation to be swapped
        """
        num1 = self.get_tag_orient_num(idx1)
        num2 = self.get_tag_orient_num(idx2)
        self._state.orientlist.swap_orientations(num1, num2)
        if ((num1 == 1 or num1 == 2 or num2 == 1 or num2 == 2)
                and (self._U is not None)):
            self._autocalculateUbAndReport()
        self.save()

    def get_ub_references(self):
        return (self._state.or0, self._state.or1)

    def get_reference_count(self):
        n_ref = self.get_number_reflections()
        n_orient = self.get_number_orientations()
        return n_ref + n_orient
#    @property
#    def reflist(self):
#        return self._state.reflist
### Calculations ###

    def set_U_manually(self, m, conv=True):
        """Manually sets U. matrix must be 3*3 Jama or python matrix.
        Turns off aution UB calcualtion."""

        # Check matrix is a 3*3 Jama matrix
        if m.__class__ != matrix:
            m = matrix(m)  # assume its a python matrix
        if m.shape[0] != 3 or m.shape[1] != 3:
            raise ValueError("Expects 3*3 matrix")

        if self._UB is None:
            print("Calculating UB matrix.")
        else:
            print("Recalculating UB matrix.")

        if conv:
            self._U = self._tobj.transform(m)
        else:
            self._U = m
        self._state.configure_calc_type(manual_U=self._U)
        if self._state.crystal is None:
            raise DiffcalcException(
                "A crystal must be specified before manually setting U")
        self._UB = self._U * self._state.crystal.B
        self.save()

    def set_UB_manually(self, m):
        """Manually sets UB. matrix must be 3*3 Jama or python matrix.
        Turns off aution UB calcualtion."""

        # Check matrix is a 3*3 Jama matrix
        if m.__class__ != matrix:
            m = matrix(m)  # assume its a python matrix
        if m.shape[0] != 3 or m.shape[1] != 3:
            raise ValueError("Expects 3*3 matrix")

        if self._tobj.R is not None:
            self._UB = self._tobj.R * m
        else:
            self._UB = m
        self._state.configure_calc_type(manual_UB=self._UB)
        self.save()

    @property
    def U(self):
        """matrix: Returns U matrix."""
        if self._U is None:
            raise DiffcalcException(
                "No U matrix has been calculated during this ub calculation")
        return self._U

    @property
    def UB(self):
        """matrix: Returns UB matrix."""
        return self._get_UB()

    def is_ub_calculated(self):
        return self._UB is not None

    def _get_UB(self):
        if not self.is_ub_calculated():
            raise DiffcalcException(
                "No UB matrix has been calculated during this ub calculation")
        else:
            return self._UB

    def _calc_UB(self, h1, h2, u1p, u2p):
        B = self._state.crystal.B
        h1c = B * h1
        h2c = B * h2

        # Create modified unit vectors t1, t2 and t3 in crystal and phi systems
        t1c = h1c
        t3c = cross3(h1c, h2c)
        t2c = cross3(t3c, t1c)

        t1p = u1p  # FIXED from h1c 9July08
        t3p = cross3(u1p, u2p)
        t2p = cross3(t3p, t1p)

        # ...and nornmalise and check that the reflections used are appropriate
        SMALL = 1e-4  # Taken from Vlieg's code

        def normalise(m):
            d = norm(m)
            if d < SMALL:
                raise DiffcalcException(
                    "Invalid UB reference data. Please check that the specified "
                    "reference reflections/orientations are not parallel.")
            return m / d

        t1c = normalise(t1c)
        t2c = normalise(t2c)
        t3c = normalise(t3c)

        t1p = normalise(t1p)
        t2p = normalise(t2p)
        t3p = normalise(t3p)

        Tc = hstack([t1c, t2c, t3c])
        Tp = hstack([t1p, t2p, t3p])
        self._U = Tp * Tc.I
        self._UB = self._U * B

    def calculate_UB(self, idx1=None, idx2=None):
        """Calculate UB matrix.
        
        Calculate UB matrix using two reference reflections and/or
        reference orientations.
        
        By default use the first two reference reflections when provided.
        If one or both reflections are not available use one or two reference
        orientations to complement mission reflection data.
        
        Parameters
        ----------
        idx1: int or str, optional
            The index or the tag of the first reflection or orientation.
        idx2: int or str, optional
            The index or the tag of the second reflection or orientation.
        """

        # Major variables:
        # h1, h2: user input reciprocal lattice vectors of the two reflections
        # h1c, h2c: user input vectors in cartesian crystal plane
        # pos1, pos2: measured diffractometer positions of the two reflections
        # u1a, u2a: measured reflection vectors in alpha frame
        # u1p, u2p: measured reflection vectors in phi frame

        # Get hkl and angle values for the first two reflections
        if self._state.reflist is None and self._state.orientlist is None:
            raise DiffcalcException("Cannot calculate a U matrix until a "
                                    "UBCalculation has been started with "
                                    "'newub'")
        if idx1 is not None and idx2 is None:
            self.calculate_UB_from_primary_only(idx1)
            return
        elif idx1 is None and idx2 is None:
            ref_data = []
            for func, idx in product(
                (self.get_reflection, self.get_orientation), (1, 2)):
                try:
                    ref_data.append(func(idx))
                except Exception:
                    pass
            try:
                ref1, ref2 = ref_data[:2]
            except ValueError:
                raise DiffcalcException(
                    "Cannot find calculate a U matrix. Please add "
                    "reference reflection and/or orientation data.")
        else:
            try:
                ref1 = self.get_reflection(idx1)
            except Exception:
                try:
                    ref1 = self.get_orientation(idx1)
                except Exception:
                    raise DiffcalcException(
                        "Cannot find first reflection or orientation with index %s"
                        % str(idx1))
            try:
                ref2 = self.get_reflection(idx2)
            except Exception:
                try:
                    ref2 = self.get_orientation(idx2)
                except Exception:
                    raise DiffcalcException(
                        "Cannot find second reflection or orientation with index %s"
                        % str(idx2))
        h1 = matrix([ref1[0]]).T  # row->column
        h2 = matrix([ref2[0]]).T

        # Compute the two reflections' reciprocal lattice vectors in the
        # cartesian crystal frame
        try:
            _, pos1, _ = ref1[:3]
            pos1.changeToRadians()
            u1p = self._strategy.calculate_q_phi(pos1)
        except AttributeError:
            _, r1, pos1 = ref1[:3]
            pos1.changeToRadians()
            [MU, _, _, ETA, CHI, PHI] = create_you_matrices(*pos1.totuple())
            Z = PHI.I * CHI.I * ETA.I * MU.I
            u1p = Z * matrix([r1]).T
        try:
            _, pos2, _ = ref2[:3]
            pos2.changeToRadians()
            u2p = self._strategy.calculate_q_phi(pos2)
        except AttributeError:
            _, r2, pos2 = ref2[:3]
            pos2.changeToRadians()
            [MU, _, _, ETA, CHI, PHI] = create_you_matrices(*pos2.totuple())
            Z = PHI.I * CHI.I * ETA.I * MU.I
            u2p = Z * matrix([r2]).T

        self._calc_UB(h1, h2, u1p, u2p)

        self._state.configure_calc_type(or0=idx1, or1=idx2)
        self.save()

    def calculate_UB_from_primary_only(self, idx=1):
        """
        Calculate orientation matrix with the shortest absolute angle change.
        Default: use first reflection.
        """

        # Algorithm from http://www.j3d.org/matrix_faq/matrfaq_latest.html

        # Get hkl and angle values for the first two reflections
        if self._state.reflist is None:
            raise DiffcalcException(
                "Cannot calculate a u matrix until a UBCalcaluation has been "
                "started with newub")
        try:
            (h, pos, _, _, _) = self.get_reflection(idx)
        except IndexError:
            raise DiffcalcException(
                "One reflection is required to calculate a u matrix")

        h = matrix([h]).T  # row->column
        pos.changeToRadians()
        B = self._state.crystal.B
        h_crystal = B * h
        h_crystal = h_crystal * (1 / norm(h_crystal))

        q_measured_phi = self._strategy.calculate_q_phi(pos)
        q_measured_phi = q_measured_phi * (1 / norm(q_measured_phi))

        rotation_axis = cross3(h_crystal, q_measured_phi)
        rotation_axis = rotation_axis * (1 / norm(rotation_axis))

        cos_rotation_angle = dot3(h_crystal, q_measured_phi)
        rotation_angle = acos(cos_rotation_angle)

        uvw = rotation_axis.T.tolist()[0]  # TODO: cleanup
        print("resulting U angle: %.5f deg" % (rotation_angle * TODEG))
        u_repr = (', '.join(['% .5f' % el for el in uvw]))
        print("resulting U axis direction: [%s]" % u_repr)

        u, v, w = uvw
        rcos = cos(rotation_angle)
        rsin = sin(rotation_angle)
        m = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]  # TODO: tidy
        m[0][0] = rcos + u * u * (1 - rcos)
        m[1][0] = w * rsin + v * u * (1 - rcos)
        m[2][0] = -v * rsin + w * u * (1 - rcos)
        m[0][1] = -w * rsin + u * v * (1 - rcos)
        m[1][1] = rcos + v * v * (1 - rcos)
        m[2][1] = u * rsin + w * v * (1 - rcos)
        m[0][2] = v * rsin + u * w * (1 - rcos)
        m[1][2] = -u * rsin + v * w * (1 - rcos)
        m[2][2] = rcos + w * w * (1 - rcos)

        if self._UB is None:
            print("Calculating UB matrix from the first reflection only.")
        else:
            print("Recalculating UB matrix from the first reflection only.")
        print("NOTE: A new UB matrix will not be automatically calculated "
              "when the orientation reflections are modified.")

        self._U = matrix(m)
        self._UB = self._U * B

        self._state.configure_calc_type(manual_U=self._U, or0=idx)
        self.save()

    def fit_ub_matrix(self, *args):
        if args is None:
            raise DiffcalcException(
                "Please specify list of reference reflection indices.")
        if len(args) < 3:
            raise DiffcalcException(
                "Need at least 3 reference reflections to fit UB matrix.")

        if len(self._state.crystal.get_lattice_params()[1]) == 6:
            new_u, uc_params = self._fit_ub_matrix_uncon(*args)
        else:
            refl_list = []
            for idx in args:
                try:
                    hkl_vals, pos, en, _, _ = self.get_reflection(idx)
                    pos.changeToRadians()
                    refl_list.append((
                        hkl_vals,
                        pos,
                        en,
                    ))
                except IndexError:
                    raise DiffcalcException(
                        "Cannot read reflection data for index %s" % str(idx))
            print("Fitting crystal lattice parameters...")
            new_lattice = fit_crystal(self._state.crystal, refl_list)
            print("Fitting orientation matrix...")
            new_u = fit_u_matrix(self._U, new_lattice, refl_list)
            uc_params = (self._state.crystal.getLattice()[0],
                         ) + new_lattice.getLattice()[1:]
        return new_u, uc_params

    def _fit_ub_matrix_uncon(self, *args):
        if args is None:
            raise DiffcalcException(
                "Please specify list of reference reflection indices.")
        if len(args) < 3:
            raise DiffcalcException(
                "Need at least 3 reference reflections to fit UB matrix.")

        x = []
        y = []
        for idx in args:
            try:
                hkl_vals, pos, en, _, _ = self.get_reflection(idx)
            except IndexError:
                raise DiffcalcException(
                    "Cannot read reflection data for index %s" % str(idx))
            pos.changeToRadians()
            x.append(hkl_vals)
            wl = 12.3984 / en
            y_tmp = self._strategy.calculate_q_phi(pos) * 2. * pi / wl
            y.append(y_tmp.T.tolist()[0])

        xm = matrix(x)
        ym = matrix(y)
        b = (xm.T * xm).I * xm.T * ym

        b1, b2, b3 = matrix(b.tolist()[0]), matrix(b.tolist()[1]), matrix(
            b.tolist()[2])
        e1 = b1 / norm(b1)
        e2 = b2 - e1 * dot3(b2.T, e1.T)
        e2 = e2 / norm(e2)
        e3 = b3 - e1 * dot3(b3.T, e1.T) - e2 * dot3(b3.T, e2.T)
        e3 = e3 / norm(e3)

        new_umatrix = matrix(e1.tolist() + e2.tolist() + e3.tolist()).T

        V = dot3(cross3(b1.T, b2.T), b3.T)
        a1 = cross3(b2.T, b3.T) * 2 * pi / V
        a2 = cross3(b3.T, b1.T) * 2 * pi / V
        a3 = cross3(b1.T, b2.T) * 2 * pi / V
        ax, bx, cx = norm(a1), norm(a2), norm(a3)
        alpha = acos(dot3(a2, a3) / (bx * cx)) * TODEG
        beta = acos(dot3(a1, a3) / (ax * cx)) * TODEG
        gamma = acos(dot3(a1, a2) / (ax * bx)) * TODEG

        lattice_name = self._state.crystal.getLattice()[0]
        return new_umatrix, (lattice_name, ax, bx, cx, alpha, beta, gamma)

    def set_miscut(self, xyz, angle, add_miscut=False):
        """Calculate U matrix using a miscut axis and an angle"""
        if xyz is None:
            rot_matrix = xyz_rotation([0, 1, 0], angle)
        else:
            rot_matrix = self._tobj.transform(xyz_rotation(xyz, angle))
        if self.is_ub_calculated() and add_miscut:
            new_U = rot_matrix * self._U
        else:
            new_U = rot_matrix
        self.set_U_manually(new_U, False)
        self.print_surface()
        self.save()

    def get_hkl_plane_distance(self, hkl):
        """Calculates and returns the distance between planes"""
        return self._state.crystal.get_hkl_plane_distance(hkl)

    def get_hkl_plane_angle(self, hkl1, hkl2):
        """Calculates and returns the angle between planes"""
        return self._state.crystal.get_hkl_plane_angle(hkl1, hkl2)

    def rescale_unit_cell(self, h, k, l, pos):
        """
        Calculate unit cell scaling parameter that matches
        given hkl position and diffractometer angles
        """
        q_vec = self._strategy.calculate_q_phi(pos)
        q_hkl = norm(q_vec) / settings.hardware.get_wavelength()
        d_hkl = self._state.crystal.get_hkl_plane_distance([h, k, l])
        sc = 1 / (q_hkl * d_hkl)
        name, a1, a2, a3, alpha1, alpha2, alpha3 = self._state.crystal.getLattice(
        )
        if abs(sc - 1.) < SMALL:
            return None, None
        ref_a1 = sc * a1 if abs(h) > SMALL else a1
        ref_a2 = sc * a2 if abs(k) > SMALL else a2
        ref_a3 = sc * a3 if abs(l) > SMALL else a3
        return sc, (name, ref_a1, ref_a2, ref_a3, alpha1, alpha2, alpha3)

    def calc_miscut(self, h, k, l, pos):
        """
        Calculate miscut angle and axis that matches
        given hkl position and diffractometer angles
        """
        q_vec = self._strategy.calculate_q_phi(pos)
        hkl_nphi = self._UB * matrix([[h], [k], [l]])
        axis = self._tobj.transform(cross3(q_vec, hkl_nphi), True)
        norm_axis = norm(axis)
        if norm_axis < SMALL:
            return None, None
        axis = axis / norm(axis)
        try:
            miscut = acos(
                bound(dot3(q_vec, hkl_nphi) /
                      (norm(q_vec) * norm(hkl_nphi)))) * TODEG
        except AssertionError:
            return None, None
        return miscut, axis.T.tolist()[0]

    def get_miscut_angle_axis(self, ubmatrix):
        y = self._get_surf_nphi()
        l = ubmatrix * y
        rotation_axis = self._tobj.transform(cross3(y, l), True)
        if abs(norm(rotation_axis)) < SMALL:
            rotation_axis = matrix('0; 0; 0')
            rotation_angle = 0
        else:
            rotation_axis = rotation_axis * (1 / norm(rotation_axis))
            cos_rotation_angle = bound(dot3(y, l) / norm(l))
            rotation_angle = acos(cos_rotation_angle) * TODEG
        return rotation_angle, rotation_axis

    def calc_hkl_offset(self, h, k, l, pol, az):
        """
        Calculate hkl orientation values that are related to
        the input hkl values by rotation with a given polar
        and azimuthal angles
        """
        hkl_nphi = self._UB * matrix([[h], [k], [l]])
        y_axis = cross3(hkl_nphi, matrix('0; 1; 0'))
        if norm3(y_axis) < SMALL:
            y_axis = cross3(hkl_nphi, matrix('0; 0; 1'))
        rot_polar = xyz_rotation(y_axis.T.tolist()[0], pol)
        rot_azimuthal = xyz_rotation(hkl_nphi.T.tolist()[0], az)
        hklrot_nphi = rot_azimuthal * rot_polar * hkl_nphi
        hklrot = self._UB.I * hklrot_nphi
        hkl_list = hklrot.T.tolist()[0]
        return hkl_list

    def calc_offset_for_hkl(self, hkl_offset, hkl_ref):
        """
        Calculate polar and azimuthal angles and scaling factor
        relating offset and reference hkl values
        """
        d_ref = self._state.crystal.get_hkl_plane_distance(hkl_ref)
        hklref_nphi = self._UB * matrix([[hkl_ref[0]], [hkl_ref[1]],
                                         [hkl_ref[2]]])
        d_offset = self._state.crystal.get_hkl_plane_distance(hkl_offset)
        hkloff_nphi = self._UB * matrix([[hkl_offset[0]], [hkl_offset[1]],
                                         [hkl_offset[2]]])
        sc = d_ref / d_offset
        par_ref_off = cross3(hklref_nphi, hkloff_nphi)
        if norm3(par_ref_off) < SMALL:
            return 0, float('nan'), sc
        y_axis = cross3(hklref_nphi, matrix('0; 1; 0'))
        if norm3(y_axis) < SMALL:
            y_axis = cross3(hklref_nphi, matrix('0; 0; 1'))
        x_axis = cross3(y_axis, hklref_nphi)
        x_coord = cos(angle_between_vectors(hkloff_nphi, x_axis))
        y_coord = cos(angle_between_vectors(hkloff_nphi, y_axis))
        pol = angle_between_vectors(hklref_nphi, hkloff_nphi)
        if abs(y_coord) < SMALL and abs(x_coord) < SMALL:
            # Set azimuthal rotation matrix to identity
            az = 0
        else:
            az = atan2(y_coord, x_coord)
        return pol, az, sc