diff --git a/config/diffcalc/test1.json b/config/diffcalc/test1.json
index ab7f00c..0b0df76 100644
--- a/config/diffcalc/test1.json
+++ b/config/diffcalc/test1.json
@@ -3,25 +3,25 @@
     "crystal": "['cubic', 7.723, 7.707, 7.723, 90.0, 89.265, 90.0]", 
     "reflist": {
         "1": {
-            "tag": null, 
+            "tag": "None", 
             "hkl": "[0.0, 1.0, 2.0]", 
             "pos": "[5.0, 9.379, 19.7895, 102.6162, 0, 0]", 
             "energy": 9.5007, 
-            "time": "2019-07-31T14:14:59.939000"
+            "time": "2019-08-15T11:11:28.003000"
         }, 
         "2": {
-            "tag": null, 
+            "tag": "None", 
             "hkl": "[2.0, 0.0, 2.0]", 
             "pos": "[5.0, 19.0754, 20.1865, 11.9693, 0, 0]", 
             "energy": 9.5007, 
-            "time": "2019-07-31T14:14:59.973000"
+            "time": "2019-08-15T11:11:28.025000"
         }, 
         "3": {
-            "tag": null, 
+            "tag": "None", 
             "hkl": "[2.0, 2.0, 2.0]", 
             "pos": "[5.0, 27.1234, 21.2368, 60.0354, 0, 0]", 
             "energy": 9.5007, 
-            "time": "2019-07-31T14:15:00.093000"
+            "time": "2019-08-15T11:11:28.082000"
         }
     }, 
     "orientlist": {}, 
diff --git a/config/settings.properties b/config/settings.properties
index 64f5b7a..4048598 100644
--- a/config/settings.properties
+++ b/config/settings.properties
@@ -1,4 +1,4 @@
-#Wed Jul 31 17:19:31 CEST 2019
+#Fri Aug 16 14:54:41 CEST 2019
 count_time=1.0
 geometry=fourcv
 roi=173 88 285 136
diff --git a/script/cpython/image_functions.py b/script/cpython/image_functions.py
index dab5206..eb6f4e9 100644
--- a/script/cpython/image_functions.py
+++ b/script/cpython/image_functions.py
@@ -1,9 +1,15 @@
 import numpy
+from scipy import signal, ndimage
 
 def img_get_int(fname,  thres1, thres2, thres3, thres4, header, width, height, depth, x1,y1,x2,y2, bx1,by1,bx2,by2 , filter_median = False, filter_nsigma = 0):
     # read actual image file    
     img = numpy.fromfile(fname, dtype=numpy.uint32)
     img.shape = height, width
+    if filter_nsigma>0:
+        img = ndimage.gaussian_filter(img, filter_nsigma)
+    elif filter_median:
+        #img = signal.medfilt2d(img.astype('d'), kernel_size=3)
+        img = ndimage.median_filter(img, size=3)
     # signal roi
     area_I  = ( x2 -  x1 + 1) * ( y2 -  y1 + 1)
     I_sum = img[y1:y2, x1:x2].sum()
@@ -11,10 +17,10 @@ def img_get_int(fname,  thres1, thres2, thres3, thres4, header, width, height, d
     thresh2_count = len(numpy.where(img>thres2)[0]) 
     thresh3_count = len(numpy.where(img>thres3)[0]) 
     thresh4_count = len(numpy.where(img>thres4)[0]) 
-
     # background roi
     I_sum_bgr = img[by1:by2, bx1:bx2].sum()
     area_bgr= (bx2 - bx1 + 1) * (by2 - by1 + 1)
+    
     return (I_sum, area_I, thresh1_count, thresh2_count, thresh3_count, thresh4_count, I_sum_bgr, area_bgr)
 
 
diff --git a/script/daq/daq4-setup.py b/script/daq/daq4-setup.py
index 89ca13c..f48b93d 100644
--- a/script/daq/daq4-setup.py
+++ b/script/daq/daq4-setup.py
@@ -6,19 +6,19 @@ set_geometry("fourcv", True)
 ###################################################################################################\
 #Constraints
 ###################################################################################################
-#hkl.con('a_eq_b')
+#con('a_eq_b')
 
 #equivalent to 'setmode 0' + 'freeze 5'
-hkl.con( 'alpha', 5) #alpha constant
+con( 'alpha', 5) #alpha constant
 
 
 #equivalent to 'setmode 1' + 'freeze 5'
-#hkl.con( 'beta', 5) #alpha constant
+#con( 'beta', 5) #alpha constant
 
 #equivalent to 'setmode 2''
-#hkl.con( 'a_eq_b', 0) #alpha constant
+#con( 'a_eq_b', 0) #alpha constant
 
-#hkl.con( 'eta', 0) 
+#con( 'eta', 0) 
 
 
 setup_axis(alpha, alpha.getMinValue(), alpha.getMaxValue())
diff --git a/script/device/Image.py b/script/device/Image.py
index 6ae1a52..f0ef8bc 100644
--- a/script/device/Image.py
+++ b/script/device/Image.py
@@ -92,7 +92,7 @@ class Image(DeviceBase, Readable):
         try:            
             ret = img_get_int(tmp_file, threshold1, threshold2, threshold3, threshold4, \
                           self.pixel.image_header_length, self.pixel.PIX_XDIM, self.pixel.PIX_YDIM,self.pixel.PIX_COLOR_DEPTH, \
-                          roi[0], roi[1], roi[2], roi[3], bkroi[0], bkroi[1], bkroi[2], bkroi[3])
+                          roi[0], roi[1], roi[2], roi[3], bkroi[0], bkroi[1], bkroi[2], bkroi[3], filter_median = True, filter_nsigma = 30)
             self.I_sum, self.area_I, self.thresh1_count, self.thresh2_count, self.thresh3_count, self.thresh4_count, self.I_sum_bgr, self.area_bgr = ret
         except:
             log("Error calculating intensity: " + str(filename) + " - " + str(sys.exc_info()[1]), False)
diff --git a/script/geometry/fourcv.py b/script/geometry/fourcv.py
index 2ac2ed2..ec2a7b2 100644
--- a/script/geometry/fourcv.py
+++ b/script/geometry/fourcv.py
@@ -1,86 +1,8 @@
 run("diffutils")
 
-###################################################################################################\
-#Setup
-###################################################################################################
-
 #alpha, delta, gamma, omegaV
 setup_diff(fourcv, energy, ("mu", "delta", "gam", "eta"), simultaneous_move=True)
 
 
-#setup_axis(alpha, alpha.getMinValue(), alpha.getMaxValue())
-#setup_axis(delta, delta.getMinValue(), 90) #delta.getMaxValue())
-#setup_axis(gamma, 0, gamma.getMaxValue())
-#setup_axis(omegaV, omegaV.getMinValue(), omegaV.getMaxValue())
-
-
 if energy.isSimulated():
     wavelength.write(1.305)
-
-
-"""
-###################################################################################################\
-#Orientation
-###################################################################################################
-help(ub.ub)
-ub.listub()
-
-#alpha delta gamma omegaV
-
-# Create a new ub calculation and set lattice parameters
-ub.newub('test')
-
-#ub.setlat('cubic', 5.114, 5.8361, 11.058, 90, 90, 90)
-#en = 8
-##ub.c2th([0, 0, 4], en)
-##ub.addref([0, 0, 4]) #From current position and ekergy
-#ub.addref([0, 0, 4], [16.2785, 0.0, 32.5568, 0.0], en)
-##ub.c2th([2, 0, 12], en)
-#ub.addref([2, 0, 12], [71.8285, 37.3082, 138.7440, 0.0], en) 
-##ub.c2th([1, -4, 10], en)
-#ub.addref([1, -4, 10], [27.7185, 17.6409 , 128.4220, 0.0], en) 
-
-#ub.setlat('cubic', 1.0, 1.0, 1.0, 90, 90, 90)
-ub.setlat('cubic', 1.305, 1.305, 1.305, 90, 90, 90)
-
-#en = 12.4
-en = 9.5
-#ub.c2th([0, 0, 4], en)
-#ub.addref([0, 0, 4]) #From current position and ekergy
-ub.addref([0, 0, 1], [30.0, 0.0, 60.0, 0.0], en)
-#ub.c2th([2, 0, 12], en)
-ub.addref([1, 0, 1], [20.0, 45.5564,90.000, 44.4437], en) 
-#ub.c2th([1, -4, 10], en)
-ub.addref([0, 1, 1], [20.0, 45.5564,90.000, 134.4437], en) 
-
-ub.ub()
-
-#ub.setub([[1.22862,0.00000,0.00000], [-0.00000,1.07663,0.00000], [-0.00000,-0.00000,0.56820]])
-
-
-# check the state
-
-ub.checkub()
-
-
-
-###################################################################################################\
-#Constraints
-###################################################################################################
-help(hkl.con)
-#hkl.con('a_eq_b')
-#hkl.con('eta:0')
-
-
-hkl.con( 'eta', 0)    #OmegaV constant
-#hkl.con( 'mu', 20)    #Alpha constant
-
-
-###################################################################################################\
-#Motion
-###################################################################################################
-
-#print  angles_to_hkl((16.278,    0.0000,   32.5568, 0.0))
-#print  angles_to_hkl((44.3400,    0.0000,  123.7322 , 0.0))
-#print hkl_to_angles(2, -2, 10)
-"""
diff --git a/script/local.py b/script/local.py
index 05fb0ed..82a06b0 100644
--- a/script/local.py
+++ b/script/local.py
@@ -3,22 +3,26 @@
 ###################################################################################################
 import os
 import os.path
+from shutil import copyfile
+import json
 
 
 ###################################################################################################
 #  Interlocks
 ###################################################################################################
 
-class MyInterlock1 (Interlock):
-    def __init__(self):
-        Interlock.__init__(self, (alpha, gamma))
+class InterlockFourcv (Interlock): 
+    def __init__(self): 
+        Interlock.__init__(self, (fourcv, alpha, delta, gamma, omegaV)) 
 
-    def check(self, (a, g)):
-        if a>=g:
+    def check(self, (p, a, d, g, o)): 
+        if fourcv.isStartingSimultaneousMove():
+            a, d, g, o = p
+        if a>g:
             return False
         return True
-
-#interlock1 = MyInterlock1()
+        
+#interlock1 = InterlockFourcv()
 
 ###################################################################################################
 #  Hardware
@@ -99,37 +103,6 @@ def set_count_time(value):
     """
     set_setting(COUNT_TIME_PREFERENCE, value )
     
-
-
-def get_geometry():
-    """
-    """
-    setting = get_setting(GEOMETRY_PREFERENCE)
-    if setting is None or (len(setting.strip()) == 0):
-        return None
-    return setting
-
-def set_geometry(value, apply = None):
-    """
-    """
-    if value is None or  (len(value.strip()) == 0):
-        set_setting(GEOMETRY_PREFERENCE, "" )
-        for name in "wavelength", "hkl_group", "h", "k", "l":
-            dev = get_device(name)
-            if dev is not None:
-                remove_device(dev)
-        return
-    filename = get_context().setup.expandPath("{script}/geometry/"+ str(value)+".py")
-    if not os.path.isfile(filename):
-        raise Exception("Invalid geometry file: " + value)
-    former = get_geometry()
-    if ((apply is None) and former != value) or (apply==True) :
-        set_setting(GEOMETRY_PREFERENCE, value )
-        run(filename)       
-
-def is_geometry_set():
-    return get_device("wavelength") is not None
-
 def get_roi():
     """
     """
@@ -162,6 +135,41 @@ def set_bg_roi(x1, y1, x2, y2):
     set_setting(BG_ROI_PREFERENCE, str(int(x1)) + " " + str(int(y1)) + " " + str(int(x2)) + " " + str(int(y2))   )
 
 
+###################################################################################################
+#  Context
+###################################################################################################
+
+
+def get_geometry():
+    """
+    """
+    setting = get_setting(GEOMETRY_PREFERENCE)
+    if setting is None or (len(setting.strip()) == 0):
+        return None
+    return setting
+
+def set_geometry(value, apply = None):
+    """
+    """
+    if value is None or  (len(value.strip()) == 0):
+        set_setting(GEOMETRY_PREFERENCE, "" )
+        for name in "wavelength", "hkl_group", "h", "k", "l":
+            dev = get_device(name)
+            if dev is not None:
+                remove_device(dev)
+        return
+    filename = get_context().setup.expandPath("{script}/geometry/"+ str(value)+".py")
+    if not os.path.isfile(filename):
+        raise Exception("Invalid geometry file: " + value)
+    former = get_geometry()
+    if ((apply is None) and former != value) or (apply==True) :
+        set_setting(GEOMETRY_PREFERENCE, value )
+        run(filename)       
+
+def is_geometry_set():
+    return get_device("wavelength") is not None
+
+
 ###################################################################################################
 #  Scan callbacks
 ###################################################################################################
@@ -377,12 +385,34 @@ def wait_for_file_size(filepath, size, timeout = None):
 
 
 def set_data_path(path):
+    """Changes data root path.
+    """
     get_context().setDataPath(path)
 
 
 def set_script_path(path):
+    """Changes script root path.
+    """
     get_context().setScriptPath(path)
 
+def backup_ub(name=None, destination = "{data}"):
+    """Copies ub matrix (default= current) to user space.
+    """
+    if not name:
+        name = ub.ubcalc._state.name
+    name = name + ".json"
+    f = settings.persistence_path + "/" + name 
+    if not os.path.isfile(f):
+        raise Exception("Invalid UB name: " + str(name))
+    copyfile(f, get_context().setup.expandPath(destination + "/" +name))
+
+def restore_ub(name, origin = "{data}"):
+    """Restores ub matrix from user space and loads it.
+    """
+    f = settings.persistence_path + "/" + name + ".json"
+    copyfile(get_context().setup.expandPath(origin + "/" +name + ".json"), f)    
+    loadub(name)    
+
 ###################################################################################################
 #  HKL commands
 ###################################################################################################
@@ -496,6 +526,7 @@ def hkllinscan(hstart, hfinish, kstart, kfinish, lstart, lfinish, number_of_step
 ###################################################################################################
 
 set_geometry(get_geometry(),True)      
+load_exp_context()
 
 
     
diff --git a/script/test/Retrieving context.py b/script/test/Retrieving context.py
new file mode 100644
index 0000000..651d894
--- /dev/null
+++ b/script/test/Retrieving context.py	
@@ -0,0 +1,5 @@
+print getub()
+
+
+print  hklci((44.3400,    0.0000,  123.7322 , 0.0))[0]
+print hklca((0, 1, 2))[0]
diff --git a/script/test/diffcalc (copy)/.cache/v/cache/lastfailed b/script/test/diffcalc (copy)/.cache/v/cache/lastfailed
new file mode 100644
index 0000000..9e26dfe
--- /dev/null
+++ b/script/test/diffcalc (copy)/.cache/v/cache/lastfailed	
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/.gitignore b/script/test/diffcalc (copy)/.gitignore
new file mode 100644
index 0000000..edda307
--- /dev/null
+++ b/script/test/diffcalc (copy)/.gitignore	
@@ -0,0 +1,9 @@
+*.class
+*~
+*.pyc
+doc/build/
+.pydevproject
+.project
+.tox
+.DS_Store
+.idea
diff --git a/script/test/diffcalc (copy)/.settings/com.wdev91.eclipse.copyright.xml b/script/test/diffcalc (copy)/.settings/com.wdev91.eclipse.copyright.xml
new file mode 100644
index 0000000..eb2e1ed
--- /dev/null
+++ b/script/test/diffcalc (copy)/.settings/com.wdev91.eclipse.copyright.xml	
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<project>
+	<owner>Diamond Light Source Ltd.</owner>
+	<copyright><![CDATA[ Copyright 2008-2011 Diamond Light Source Ltd.
+ This file is part of Diffcalc.
+
+ Diffcalc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Diffcalc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.]]></copyright>
+	<header contentId="org.eclipse.core.runtime.text" postBlankLines="2" lineFormat="false" preserveFirstLine="false">
+		<beginLine><![CDATA[###]]></beginLine>
+		<linePrefix><![CDATA[#]]></linePrefix>
+		<endLine><![CDATA[###]]></endLine>
+	</header>
+	<header contentId="org.python.pydev.pythonfile" postBlankLines="1" lineFormat="false" preserveFirstLine="false">
+		<beginLine><![CDATA[###]]></beginLine>
+		<linePrefix><![CDATA[#]]></linePrefix>
+		<endLine><![CDATA[###]]></endLine>
+	</header>
+</project>
diff --git a/script/test/diffcalc (copy)/.settings/org.eclipse.core.resources.prefs b/script/test/diffcalc (copy)/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..d0a9e4e
--- /dev/null
+++ b/script/test/diffcalc (copy)/.settings/org.eclipse.core.resources.prefs	
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+encoding//doc/source/conf.py=utf-8
+encoding/<project>=UTF-8
diff --git a/script/test/diffcalc (copy)/.settings/org.eclipse.core.runtime.prefs b/script/test/diffcalc (copy)/.settings/org.eclipse.core.runtime.prefs
new file mode 100644
index 0000000..5a0ad22
--- /dev/null
+++ b/script/test/diffcalc (copy)/.settings/org.eclipse.core.runtime.prefs	
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+line.separator=\n
diff --git a/script/test/diffcalc (copy)/.travis.yml b/script/test/diffcalc (copy)/.travis.yml
new file mode 100644
index 0000000..2ee17ea
--- /dev/null
+++ b/script/test/diffcalc (copy)/.travis.yml	
@@ -0,0 +1,21 @@
+# based on https://www.topbug.net/blog/2012/05/27/use-travis-ci-with-jython/
+
+language: python
+
+python:
+  - "2.7"
+
+env:
+  - JYTHON=false
+  - JYTHON=true
+
+install:
+  - if [ "$JYTHON" == "true" ]; then . install-jython-environment.sh; fi
+  - if [ "$JYTHON" == "false" ]; then pip install --upgrade pytest; pip install pytest-xdist; fi
+ 
+before_script:
+  - if [ "$JYTHON" == "true" ]; then export PYTEST=$HOME/jython/bin/pytest; else export PYTEST=pytest; fi
+  - echo PYTEST:- $PYTEST
+
+script: $PYTEST
+
diff --git a/script/test/diffcalc (copy)/COPYING b/script/test/diffcalc (copy)/COPYING
new file mode 100644
index 0000000..20d40b6
--- /dev/null
+++ b/script/test/diffcalc (copy)/COPYING	
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/Makefile b/script/test/diffcalc (copy)/Makefile
new file mode 100644
index 0000000..221a775
--- /dev/null
+++ b/script/test/diffcalc (copy)/Makefile	
@@ -0,0 +1,52 @@
+
+test-all: test-python test-jython test-integration test-launcher
+
+test-python:
+	py.test
+	
+test-jython:
+	export CLASSPATH=$(HOME)/lib/Jama-1.0.3.jar:$(CLASSPATH); echo $$CLASSPATH; $(HOME)/jython/bin/py.test
+	
+test-integration:
+	py.test --boxed integration_checks.py
+	
+test-launcher:
+	./diffcalc.py --help
+	./diffcalc.py --modules
+	./diffcalc.py --non-interactive --python sixcircle
+
+install-jython:
+	./install-jython-environment.sh
+	
+doc-source:
+	./diffcalc.py --non-interactive --make-manuals-source
+
+doc-html:
+	cd doc; make html
+	
+doc-pdf:
+	cd doc; make pdf
+	
+doc-all:
+	cd doc; make all
+	
+doc-clean:
+	cd doc; make clean
+
+help:
+	@echo
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo
+	@echo "  test-all"
+	@echo "  test-python"
+	@echo "  test-jython"
+	@echo "  test-integration"
+	@echo "  test-launcher"
+	@echo "  install-jython"
+	@echo
+	@echo "  doc-source  :  to expand *_template.rst to *.rst"
+	@echo "  doc-html"
+	@echo "  doc-pdf"
+	@echo "  doc-all"
+	@echo "  doc-clean"
+	@echo
diff --git a/script/test/diffcalc (copy)/README.rst b/script/test/diffcalc (copy)/README.rst
new file mode 100644
index 0000000..95f0ad3
--- /dev/null
+++ b/script/test/diffcalc (copy)/README.rst	
@@ -0,0 +1,513 @@
+Diffcalc - A Diffraction Condition Calculator for Diffractometer Control
+========================================================================
+
+Diffcalc is a python/jython based diffraction condition calculator used for
+controlling diffractometers within reciprocal lattice space. It performs the
+same task as the fourc, sixc, twoc, kappa, psic and surf macros from SPEC.
+
+There is a `user guide <https://diffcalc.readthedocs.io/en/latest/youmanual.html>`_ and `developer guide <https://diffcalc.readthedocs.io/en/latest/developer/contents.html>`_, both at `diffcalc.readthedocs.io <https://diffcalc.readthedocs.io>`_
+
+|Travis| |Read the docs|
+
+.. |Travis| image:: https://travis-ci.org/DiamondLightSource/diffcalc.svg?branch=master
+    :target: https://travis-ci.org/DiamondLightSource/diffcalc
+    :alt: Build Status
+
+.. |Read the docs| image:: https://readthedocs.org/projects/diffcalc/badge/?version=latest
+    :target: http://diffcalc.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. contents::
+
+.. section-numbering::
+
+Software compatibility
+----------------------
+
+- Written in Python using numpy
+- Works in Jython using Jama
+- Runs directly in `OpenGDA<http://www.opengda.org>`
+- Runs in in Python or IPython using minimal OpenGda emulation (included)
+- Contact us for help running in your environment
+
+Diffractometer compatibility
+----------------------------
+
+Diffcalc’s standard calculation engine is an implementation of [You1999]_ and
+[Busing1967]_. Diffcalc works with any diffractometer which is a subset of:
+
+ .. image:: https://raw.githubusercontent.com/DiamondLightSource/diffcalc/master/doc/source/youmanual_images/4s_2d_diffractometer.png
+     :alt: 4s + 2d six-circle diffractometer, from H.You (1999)
+     :width: 50%
+     :align: center
+
+Diffcalc can be configured to work with any diffractometer geometry which is a
+subset of this. For example, a five-circle diffractometer might be missing the
+nu circle above.
+
+Note that the first versions of Diffcalc were based on [Vlieg1993]_ and
+[Vlieg1998]_ and a ‘Vlieg’ engine is still available.  There is also an engine
+based on [Willmott2011]_. The ‘You’ engine is more generic and the plan is to
+remove the old ‘Vlieg’ engine once beamlines have been migrated.
+
+Installation
+------------
+
+Check it out::
+
+   $ git clone https://github.com/DiamondLightSource/diffcalc.git
+   Cloning into 'diffcalc'...
+
+At Diamond Diffcalc may be installed within an OpenGDA deployment and is
+available via the 'module' system from bash.
+
+Starting
+--------
+
+Start diffcalc in ipython using a sixcircle dummy diffractometer::
+
+   $ cd diffcalc
+   $ ./diffcalc.py --help
+   ...
+
+   $ ./diffcalc.py sixcircle
+
+   Running: "ipython --no-banner --HistoryManager.hist_file=/tmp/ipython_hist_zrb13439.sqlite -i -m diffcmd.start sixcircle False"
+
+   ---------------------------------- DIFFCALC -----------------------------------
+   Startup script: '/Users/zrb13439/git/diffcalc/startup/sixcircle.py'
+   Loading ub calculation: 'test'
+   ------------------------------------ Help -------------------------------------
+   Quick:  https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst
+   Manual: https://diffcalc.readthedocs.io
+   Type:   > help ub
+           > help hkl
+   -------------------------------------------------------------------------------
+   In [1]:
+
+Within Diamond use::
+
+   $ module load diffcalc
+   $ diffcalc --help
+   ...
+   $ diffcalc sixcircle
+
+Trying it out
+-------------
+
+Type ``demo.all()`` to see it working and then move try the following quick
+start guide::
+
+   >>> demo.all()
+   ...
+
+Getting help
+------------
+
+To view help with orientation and then moving in hkl space::
+
+   >>> help ub
+   ...
+   >>> help hkl
+   ...
+
+Configuring a UB calculation
+----------------------------
+See the full `user manual<https://diffcalc.readthedocs.io`> for many more
+options and an explanation of what this all means.
+
+To load the last used UB-calculation::
+
+   >>> lastub
+   Loading ub calculation: 'mono-Si'
+
+To load a previous UB-calculation::
+
+   >>> listub
+   UB calculations in: /Users/walton/.diffcalc/i16
+
+   0) mono-Si            15 Feb 2017 (22:32)
+   1) i16-32             13 Feb 2017 (18:32)
+
+   >>> loadub 0
+
+To create a new UB-calculation::
+
+   >>> newub 'example'
+   >>> setlat '1Acube' 1 1 1 90 90 90
+
+Find U matrix from two reflections::
+
+   >>> pos wl 1
+   wl:        1.0000
+   >>> c2th [0 0 1]
+   59.99999999999999
+
+   >>> pos sixc [0 60 0 30 90 0]
+   sixc:     mu:  0.0000 delta:  60.0000 gam:  0.0000 eta:  30.0000 chi:  90.0000 phi:  0.0000 
+   >>> addref [0 0 1]
+
+   >>> pos sixc [0 90 0 45 45 90]
+   sixc:     mu:  0.0000 delta:  90.0000 gam:  0.0000 eta:  45.0000 chi:  45.0000 phi:  90.0000 
+   >>> addref [0 1 1]
+   Calculating UB matrix.
+
+
+Check that it looks good::
+
+   >>> checkub
+   
+        ENERGY     H     K     L    H_COMP   K_COMP   L_COMP     TAG
+    1  12.3984  0.00  0.00  1.00    0.0000   0.0000   1.0000        
+    2  12.3984  0.00  1.00  1.00    0.0000   1.0000   1.0000        
+
+To see the resulting UB-calculation::
+
+   >>> ub
+   UBCALC
+   
+      name:       example
+   
+      n_phi:      0.00000   0.00000   1.00000 <- set
+      n_hkl:     -0.00000   0.00000   1.00000
+      miscut:     None
+   
+   CRYSTAL
+   
+      name:        1Acube
+   
+      a, b, c:    1.00000   1.00000   1.00000
+                 90.00000  90.00000  90.00000
+   
+      B matrix:   6.28319   0.00000   0.00000
+                  0.00000   6.28319   0.00000
+                  0.00000   0.00000   6.28319
+   
+   UB MATRIX
+   
+      U matrix:   1.00000   0.00000   0.00000
+                  0.00000   1.00000   0.00000
+                  0.00000   0.00000   1.00000
+   
+      U angle:    0
+   
+      UB matrix:  6.28319   0.00000   0.00000
+                  0.00000   6.28319   0.00000
+                  0.00000   0.00000   6.28319
+   
+   REFLECTIONS
+   
+        ENERGY     H     K     L        MU    DELTA      GAM      ETA      CHI      PHI  TAG
+      1 12.398  0.00  0.00  1.00    0.0000  60.0000   0.0000  30.0000  90.0000   0.0000  
+      2 12.398  0.00  1.00  1.00    0.0000  90.0000   0.0000  45.0000  45.0000  90.0000  
+
+Setting the reference vector
+----------------------------
+See the full `user manual<https://diffcalc.readthedocs.io`> for many more
+options and an explanation of what this all means.
+
+By default the reference vector is set parallel to the phi axis. That is,
+along the z-axis of the phi coordinate frame.
+
+The `ub` command shows the current reference vector, along with any inferred
+miscut, at the top its report (or it can be shown by calling ``setnphi`` or
+``setnhkl'`` with no args)::
+
+   >>> ub
+   ...
+   n_phi:      0.00000   0.00000   1.00000 <- set
+   n_hkl:     -0.00000   0.00000   1.00000
+   miscut:     None
+   ...
+
+Constraining solutions for moving in hkl space
+----------------------------------------------
+See the full `user manual<https://diffcalc.readthedocs.io`> for many more
+options and an explanation of what this all means.
+
+To get help and see current constraints::
+
+   >>> help con
+   ...
+
+   >>> con
+       DET        REF        SAMP
+       ------     ------     ------
+       delta  --> a_eq_b --> mu
+   --> gam        alpha      eta
+       qaz        beta       chi
+       naz        psi        phi
+                             mu_is_gam
+   
+       gam  : 0.0000
+       a_eq_b
+       mu   : 0.0000
+   
+       Type 'help con' for instructions
+
+Three constraints can be given: zero or one from the DET and REF columns and the
+remainder from the SAMP column. Not all combinations are currently available.
+Use ``help con`` to see a summary if you run into troubles.
+
+To configure four-circle vertical scattering::
+
+   >>> con gam 0 mu 0 a_eq_b
+       gam  : 0.0000
+       a_eq_b
+       mu   : 0.0000
+
+Moving in hkl space
+-------------------
+
+Simulate moving to a reflection::
+
+   >>> sim hkl [0 1 1]
+   sixc would move to:
+        mu :    0.0000
+     delta :   90.0000
+       gam :    0.0000
+       eta :   45.0000
+       chi :   45.0000
+       phi :   90.0000
+   
+     alpha :   30.0000
+      beta :   30.0000
+       naz :   35.2644
+       psi :   90.0000
+       qaz :   90.0000
+       tau :   45.0000
+     theta :   45.0000
+
+Move to reflection::
+
+   >>> pos hkl [0 1 1]
+   hkl:      h: 0.00000 k: 1.00000 l: 1.00000 
+
+   >>> pos sixc
+   sixc:     mu:  0.0000 delta:  90.0000 gam:  0.0000 eta:  45.0000 chi:  45.0000 phi:  90.0000 
+
+
+Scanning in hkl space
+---------------------
+
+Scan an hkl axis (and read back settings)::
+
+   >>> scan l 0 1 .2 sixc
+         l       mu     delta      gam       eta      chi       phi
+   -------  -------  --------  -------  --------  -------  --------
+   0.00000   0.0000   60.0000   0.0000   30.0000   0.0000   90.0000
+   0.20000   0.0000   61.3146   0.0000   30.6573   11.3099   90.0000
+   0.40000   0.0000   65.1654   0.0000   32.5827   21.8014   90.0000
+   0.60000   0.0000   71.3371   0.0000   35.6685   30.9638   90.0000
+   0.80000   0.0000   79.6302   0.0000   39.8151   38.6598   90.0000
+   1.00000   0.0000   90.0000   0.0000   45.0000   45.0000   90.0000
+
+Scan a constraint (and read back virtual angles and eta)::
+
+   >>> con psi
+       gam  : 0.0000
+   !   psi  : ---
+       mu   : 0.0000
+   >>> scan psi 70 110 10 hklverbose [0 1 1] eta
+        psi       eta        h        k        l     theta       qaz     alpha       naz       tau       psi      beta
+   --------  --------  -------  -------  -------  --------  --------  --------  --------  --------  --------  --------
+   70.00000   26.1183  0.00000  1.00000  1.00000  45.00000  90.00000  19.20748  45.28089  45.00000  70.00000  42.14507
+   80.00000   35.1489  -0.00000  1.00000  1.00000  45.00000  90.00000  24.40450  40.12074  45.00000  80.00000  35.93196
+   90.00000   45.0000  0.00000  1.00000  1.00000  45.00000  90.00000  30.00000  35.26439  45.00000  90.00000  30.00000
+   100.00000   54.8511  -0.00000  1.00000  1.00000  45.00000  90.00000  35.93196  30.68206  45.00000  100.00000  24.40450
+   110.00000   63.8817  -0.00000  1.00000  1.00000  45.00000  90.00000  42.14507  26.34100  45.00000  110.00000  19.20748
+
+
+Orientation Commands
+--------------------
+
++-----------------------------+---------------------------------------------------+
+| **STATE**                                                                       |
++-----------------------------+---------------------------------------------------+
+| **-- newub** {'name'}       | start a new ub calculation name                   |
++-----------------------------+---------------------------------------------------+
+| **-- loadub** 'name' | num  | load an existing ub calculation                   |
++-----------------------------+---------------------------------------------------+
+| **-- lastub**               | load the last used ub calculation                 |
++-----------------------------+---------------------------------------------------+
+| **-- listub**               | list the ub calculations available to load        |
++-----------------------------+---------------------------------------------------+
+| **-- rmub** 'name'|num      | remove existing ub calculation                    |
++-----------------------------+---------------------------------------------------+
+| **-- saveubas** 'name'      | save the ub calculation with a new name           |
++-----------------------------+---------------------------------------------------+
+| **LATTICE**                                                                     |
++-----------------------------+---------------------------------------------------+
+| **-- setlat**               | interactively enter lattice parameters (Angstroms |
+|                             | and Deg)                                          |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a        | assumes cubic                                     |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b      | assumes tetragonal                                |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b c    | assumes ortho                                     |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b c    | assumes mon/hex with gam not equal to 90          |
+| gamma                       |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b c    | arbitrary                                         |
+| alpha beta gamma            |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- c2th** [h k l]         | calculate two-theta angle for reflection          |
++-----------------------------+---------------------------------------------------+
+| **-- hklangle** [h1 k1 l1]  | calculate angle between [h1 k1 l1] and [h2 k2 l2] |
+| [h2 k2 l2]                  | crystal planes                                    |
++-----------------------------+---------------------------------------------------+
+| **REFERENCE (SURFACE)**                                                         |
++-----------------------------+---------------------------------------------------+
+| **-- setnphi** {[x y z]}    | sets or displays n_phi reference                  |
++-----------------------------+---------------------------------------------------+
+| **-- setnhkl** {[h k l]}    | sets or displays n_hkl reference                  |
++-----------------------------+---------------------------------------------------+
+| **REFLECTIONS**                                                                 |
++-----------------------------+---------------------------------------------------+
+| **-- showref**              | shows full reflection list                        |
++-----------------------------+---------------------------------------------------+
+| **-- addref**               | add reflection interactively                      |
++-----------------------------+---------------------------------------------------+
+| **-- addref** [h k l]       | add reflection with current position and energy   |
+| {'tag'}                     |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- addref** [h k l] (p1,  | add arbitrary reflection                          |
+| .., pN) energy {'tag'}      |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- editref** num          | interactively edit a reflection                   |
++-----------------------------+---------------------------------------------------+
+| **-- delref** num           | deletes a reflection (numbered from 1)            |
++-----------------------------+---------------------------------------------------+
+| **-- clearref**             | deletes all the reflections                       |
++-----------------------------+---------------------------------------------------+
+| **-- swapref**              | swaps first two reflections used for calculating  |
+|                             | U matrix                                          |
++-----------------------------+---------------------------------------------------+
+| **-- swapref** num1 num2    | swaps two reflections (numbered from 1)           |
++-----------------------------+---------------------------------------------------+
+| **CRYSTAL ORIENTATIONS**                                                        |
++-----------------------------+---------------------------------------------------+
+| **-- showorient**           | shows full list of crystal orientations           |
++-----------------------------+---------------------------------------------------+
+| **-- addorient**            | add crystal orientation interactively             |
++-----------------------------+---------------------------------------------------+
+| **-- addorient** [h k l]    | add crystal orientation in laboratory frame       |
+| [x y z] {'tag'}             |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- editorient** num       | interactively edit a crystal orientation          |
++-----------------------------+---------------------------------------------------+
+| **-- delorient** num        | deletes a crystal orientation (numbered from 1)   |
++-----------------------------+---------------------------------------------------+
+| **-- clearorient**          | deletes all the crystal orientations              |
++-----------------------------+---------------------------------------------------+
+| **-- swaporient**           | swaps first two crystal orientations used for     |
+|                             | calculating U matrix                              |
++-----------------------------+---------------------------------------------------+
+| **-- swaporient** num1 num2 | swaps two crystal orientations (numbered from 1)  |
++-----------------------------+---------------------------------------------------+
+| **UB MATRIX**                                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- checkub**              | show calculated and entered hkl values for        |
+|                             | reflections                                       |
++-----------------------------+---------------------------------------------------+
+| **-- setu**                 | manually set u matrix                             |
+| {[[..][..][..]]}            |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- setub**                | manually set ub matrix                            |
+| {[[..][..][..]]}            |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- calcub**               | (re)calculate u matrix from ref1 and ref2         |
++-----------------------------+---------------------------------------------------+
+| **-- trialub**              | (re)calculate u matrix from ref1 only (check      |
+|                             | carefully)                                        |
++-----------------------------+---------------------------------------------------+
+| **-- refineub** {[h k l]}   | refine unit cell dimensions and U matrix to match |
+| {pos}                       | diffractometer angles for a given hkl value       |
++-----------------------------+---------------------------------------------------+
+| **-- addmiscut** angle      | apply miscut to U matrix using a specified miscut |
+| {[x y z]}                   | angle in degrees and a rotation axis              |
+|                             | (default: [0 1 0])                                |
++-----------------------------+---------------------------------------------------+
+| **-- setmiscut** angle      | manually set U matrix using a specified miscut    |
+| {[x y z]}                   | angle in degrees and a rotation axis              |
+|                             | (default: [0 1 0])                                |
++-----------------------------+---------------------------------------------------+
+
+Motion Commands
+---------------
+
++-----------------------------+---------------------------------------------------+
+| **CONSTRAINTS**                                                                 |
++-----------------------------+---------------------------------------------------+
+| **-- con**                  | list available constraints and values             |
++-----------------------------+---------------------------------------------------+
+| **-- con** <name> {val}     | constrains and optionally sets one constraint     |
++-----------------------------+---------------------------------------------------+
+| **-- con** <name> {val}     | clears and then fully constrains                  |
+| <name> {val} <name> {val}   |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- uncon** <name>         | remove constraint                                 |
++-----------------------------+---------------------------------------------------+
+| **HKL**                                                                         |
++-----------------------------+---------------------------------------------------+
+| **-- allhkl** [h k l]       | print all hkl solutions ignoring limits           |
++-----------------------------+---------------------------------------------------+
+| **HARDWARE**                                                                    |
++-----------------------------+---------------------------------------------------+
+| **-- hardware**             | show diffcalc limits and cuts                     |
++-----------------------------+---------------------------------------------------+
+| **-- setcut** {name {val}}  | sets cut angle                                    |
++-----------------------------+---------------------------------------------------+
+| **-- setmin** {axis {val}}  | set lower limits used by auto sector code (None   |
+|                             | to clear)                                         |
++-----------------------------+---------------------------------------------------+
+| **-- setmax** {name {val}}  | sets upper limits used by auto sector code (None  |
+|                             | to clear)                                         |
++-----------------------------+---------------------------------------------------+
+| **MOTION**                                                                      |
++-----------------------------+---------------------------------------------------+
+| **-- sim** hkl scn          | simulates moving scannable (not all)              |
++-----------------------------+---------------------------------------------------+
+| **-- sixc**                 | show Eularian position                            |
++-----------------------------+---------------------------------------------------+
+| **-- pos** sixc [mu, delta, | move to Eularian position(None holds an axis      |
+| gam, eta, chi, phi]         | still)                                            |
++-----------------------------+---------------------------------------------------+
+| **-- sim** sixc [mu, delta, | simulate move to Eulerian positionsixc            |
+| gam, eta, chi, phi]         |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- hkl**                  | show hkl position                                 |
++-----------------------------+---------------------------------------------------+
+| **-- pos** hkl [h k l]      | move to hkl position                              |
++-----------------------------+---------------------------------------------------+
+| **-- pos** {h | k | l} val  | move h, k or l to val                             |
++-----------------------------+---------------------------------------------------+
+| **-- sim** hkl [h k l]      | simulate move to hkl position                     |
++-----------------------------+---------------------------------------------------+
+
+
+References
+----------
+
+.. [You1999] H. You. *Angle calculations for a '4S+2D' six-circle diffractometer.*
+   J. Appl. Cryst. (1999). **32**, 614-623. `(pdf link)
+   <http://journals.iucr.org/j/issues/1999/04/00/hn0093/hn0093.pdf>`__.
+
+.. [Busing1967] W. R. Busing and H. A. Levy. *Angle calculations for 3- and 4-circle X-ray
+   and neutron diffractometers.* Acta Cryst. (1967). **22**, 457-464. `(pdf link)
+   <http://journals.iucr.org/q/issues/1967/04/00/a05492/a05492.pdf>`__.
+
+.. [Vlieg1993] Martin Lohmeier and Elias Vlieg. *Angle calculations for a six-circle
+   surface x-ray diffractometer.* J. Appl. Cryst. (1993). **26**, 706-716. `(pdf link)
+   <http://journals.iucr.org/j/issues/1993/05/00/la0044/la0044.pdf>`__.
+
+.. [Vlieg1998] Elias Vlieg. *A (2+3)-type surface diffractometer: mergence of the z-axis and
+   (2+2)-type geometries.* J. Appl. Cryst. (1998). **31**, 198-203. `(pdf link)
+   <http://journals.iucr.org/j/issues/1998/02/00/pe0028/pe0028.pdf>`__.
+
+.. [Willmott2011] C. M. Schlepütz, S. O. Mariager, S. A. Pauli, R. Feidenhans'l and
+   P. R. Willmott. *Angle calculations for a (2+3)-type diffractometer: focus
+   on area detectors.* J. Appl. Cryst. (2011). **44**, 73-83. `(pdf link)
+   <http://journals.iucr.org/j/issues/2011/01/00/db5088/db5088.pdf>`__.
diff --git a/script/test/diffcalc (copy)/README_template.rst b/script/test/diffcalc (copy)/README_template.rst
new file mode 100644
index 0000000..f62cc5f
--- /dev/null
+++ b/script/test/diffcalc (copy)/README_template.rst	
@@ -0,0 +1,267 @@
+Diffcalc - A Diffraction Condition Calculator for Diffractometer Control
+========================================================================
+
+Diffcalc is a python/jython based diffraction condition calculator used for
+controlling diffractometers within reciprocal lattice space. It performs the
+same task as the fourc, sixc, twoc, kappa, psic and surf macros from SPEC.
+
+There is a `user guide <https://diffcalc.readthedocs.io/en/latest/youmanual.html>`_ and `developer guide <https://diffcalc.readthedocs.io/en/latest/developer/contents.html>`_, both at `diffcalc.readthedocs.io <https://diffcalc.readthedocs.io>`_
+
+|Travis| |Read the docs|
+
+.. |Travis| image:: https://travis-ci.org/DiamondLightSource/diffcalc.svg?branch=master
+    :target: https://travis-ci.org/DiamondLightSource/diffcalc
+    :alt: Build Status
+
+.. |Read the docs| image:: https://readthedocs.org/projects/diffcalc/badge/?version=latest
+    :target: http://diffcalc.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. contents::
+
+.. section-numbering::
+
+Software compatibility
+----------------------
+
+- Written in Python using numpy
+- Works in Jython using Jama
+- Runs directly in `OpenGDA<http://www.opengda.org>`
+- Runs in in Python or IPython using minimal OpenGda emulation (included)
+- Contact us for help running in your environment
+
+Diffractometer compatibility
+----------------------------
+
+Diffcalc’s standard calculation engine is an implementation of [You1999]_ and
+[Busing1967]_. Diffcalc works with any diffractometer which is a subset of:
+
+ .. image:: https://raw.githubusercontent.com/DiamondLightSource/diffcalc/master/doc/source/youmanual_images/4s_2d_diffractometer.png
+     :alt: 4s + 2d six-circle diffractometer, from H.You (1999)
+     :width: 50%
+     :align: center
+
+Diffcalc can be configured to work with any diffractometer geometry which is a
+subset of this. For example, a five-circle diffractometer might be missing the
+nu circle above.
+
+Note that the first versions of Diffcalc were based on [Vlieg1993]_ and
+[Vlieg1998]_ and a ‘Vlieg’ engine is still available.  There is also an engine
+based on [Willmott2011]_. The ‘You’ engine is more generic and the plan is to
+remove the old ‘Vlieg’ engine once beamlines have been migrated.
+
+If we choose the x axis parallel to b, the yaxis intheplaneofblandb2,andthezaxis perpendicular to that plane,
+
+Installation
+------------
+
+Check it out::
+
+   $ git clone https://github.com/DiamondLightSource/diffcalc.git
+   Cloning into 'diffcalc'...
+
+At Diamond Diffcalc may be installed within an OpenGDA deployment and is
+available via the 'module' system from bash.
+
+Starting
+--------
+
+Start diffcalc in ipython using a sixcircle dummy diffractometer::
+
+   $ cd diffcalc
+   $ ./diffcalc.py --help
+   ...
+
+   $ ./diffcalc.py sixcircle
+
+   Running: "ipython --no-banner --HistoryManager.hist_file=/tmp/ipython_hist_zrb13439.sqlite -i -m diffcmd.start sixcircle False"
+
+   ---------------------------------- DIFFCALC -----------------------------------
+   Startup script: '/Users/zrb13439/git/diffcalc/startup/sixcircle.py'
+   Loading ub calculation: 'test'
+   ------------------------------------ Help -------------------------------------
+   Quick:  https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst
+   Manual: https://diffcalc.readthedocs.io
+   Type:   > help ub
+           > help hkl
+   -------------------------------------------------------------------------------
+   In [1]:
+
+Within Diamond use::
+
+   $ module load diffcalc
+   $ diffcalc --help
+   ...
+   $ diffcalc sixcircle
+
+Trying it out
+-------------
+
+Type ``demo.all()`` to see it working and then move try the following quick
+start guide::
+
+   >>> demo.all()
+   ...
+
+Getting help
+------------
+
+To view help with orientation and then moving in hkl space::
+
+   >>> help ub
+   ...
+   >>> help hkl
+   ...
+
+Configuring a UB calculation
+----------------------------
+See the full `user manual<https://diffcalc.readthedocs.io`> for many more
+options and an explanation of what this all means.
+
+To load the last used UB-calculation::
+
+   >>> lastub
+   Loading ub calculation: 'mono-Si'
+
+To load a previous UB-calculation::
+
+   >>> listub
+   UB calculations in: /Users/walton/.diffcalc/i16
+
+   0) mono-Si            15 Feb 2017 (22:32)
+   1) i16-32             13 Feb 2017 (18:32)
+
+   >>> loadub 0
+
+To create a new UB-calculation::
+
+   ==> newub 'example'
+   ==> setlat '1Acube' 1 1 1 90 90 90
+
+where the basis is defined by Busing & Levy:
+
+	"...we choose the x axis parallel to b, the y axis in the plane of bl
+	and b2, and the zaxis perpendicular to that plane."
+
+
+Find U matrix from two reflections::
+
+   ==> pos wl 1
+   ==> c2th [0 0 1]
+   59.99999999999999
+
+   ==> pos sixc [0 60 0 30 90 0]
+   ==> addref [0 0 1]
+
+   ==> pos sixc [0 90 0 45 45 90]
+   ==> addref [0 1 1]
+
+
+Check that it looks good::
+
+   ==> checkub
+
+To see the resulting UB-calculation::
+
+   ==> ub
+
+Setting the reference vector
+----------------------------
+See the full `user manual<https://diffcalc.readthedocs.io`> for many more
+options and an explanation of what this all means.
+
+By default the reference vector is set parallel to the phi axis. That is,
+along the z-axis of the phi coordinate frame.
+
+The `ub` command shows the current reference vector, along with any inferred
+miscut, at the top its report (or it can be shown by calling ``setnphi`` or
+``setnhkl'`` with no args)::
+
+   >>> ub
+   ...
+   n_phi:      0.00000   0.00000   1.00000 <- set
+   n_hkl:     -0.00000   0.00000   1.00000
+   miscut:     None
+   ...
+
+Constraining solutions for moving in hkl space
+----------------------------------------------
+See the full `user manual<https://diffcalc.readthedocs.io`> for many more
+options and an explanation of what this all means.
+
+To get help and see current constraints::
+
+   >>> help con
+   ...
+
+   ==> con
+
+Three constraints can be given: zero or one from the DET and REF columns and the
+remainder from the SAMP column. Not all combinations are currently available.
+Use ``help con`` to see a summary if you run into troubles.
+
+To configure four-circle vertical scattering::
+
+   ==> con gam 0 mu 0 a_eq_b
+
+Moving in hkl space
+-------------------
+
+Simulate moving to a reflection::
+
+   ==> sim hkl [0 1 1]
+
+Move to reflection::
+
+   ==> pos hkl [0 1 1]
+
+   ==> pos sixc
+
+
+Scanning in hkl space
+---------------------
+
+Scan an hkl axis (and read back settings)::
+
+   ==> scan l 0 1 .2 sixc
+
+Scan a constraint (and read back virtual angles and eta)::
+
+   ==> con psi
+   ==> scan psi 70 110 10 hklverbose [0 1 1] eta
+
+
+Orientation Commands
+--------------------
+
+==> UB_HELP_TABLE
+
+Motion Commands
+---------------
+
+==> HKL_HELP_TABLE
+
+
+References
+----------
+
+.. [You1999] H. You. *Angle calculations for a '4S+2D' six-circle diffractometer.*
+   J. Appl. Cryst. (1999). **32**, 614-623. `(pdf link)
+   <http://journals.iucr.org/j/issues/1999/04/00/hn0093/hn0093.pdf>`__.
+
+.. [Busing1967] W. R. Busing and H. A. Levy. *Angle calculations for 3- and 4-circle X-ray
+   and neutron diffractometers.* Acta Cryst. (1967). **22**, 457-464. `(pdf link)
+   <http://journals.iucr.org/q/issues/1967/04/00/a05492/a05492.pdf>`__.
+
+.. [Vlieg1993] Martin Lohmeier and Elias Vlieg. *Angle calculations for a six-circle
+   surface x-ray diffractometer.* J. Appl. Cryst. (1993). **26**, 706-716. `(pdf link)
+   <http://journals.iucr.org/j/issues/1993/05/00/la0044/la0044.pdf>`__.
+
+.. [Vlieg1998] Elias Vlieg. *A (2+3)-type surface diffractometer: mergence of the z-axis and
+   (2+2)-type geometries.* J. Appl. Cryst. (1998). **31**, 198-203. `(pdf link)
+   <http://journals.iucr.org/j/issues/1998/02/00/pe0028/pe0028.pdf>`__.
+
+.. [Willmott2011] C. M. Schlepütz, S. O. Mariager, S. A. Pauli, R. Feidenhans'l and
+   P. R. Willmott. *Angle calculations for a (2+3)-type diffractometer: focus
+   on area detectors.* J. Appl. Cryst. (2011). **44**, 73-83. `(pdf link)
+   <http://journals.iucr.org/j/issues/2011/01/00/db5088/db5088.pdf>`__.
diff --git a/script/test/diffcalc (copy)/buckminster.cspec b/script/test/diffcalc (copy)/buckminster.cspec
new file mode 100644
index 0000000..745b4c3
--- /dev/null
+++ b/script/test/diffcalc (copy)/buckminster.cspec	
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?><cs:cspec xmlns:cs="http://www.eclipse.org/buckminster/CSpec-1.0" name="diffcalc" componentType="buckminster" version="1.1.0">
+    <cs:artifacts>
+        <cs:public name="containsDocumentationSource"/>
+    </cs:artifacts>
+</cs:cspec>
diff --git a/script/test/diffcalc (copy)/diffcalc.py b/script/test/diffcalc (copy)/diffcalc.py
new file mode 100755
index 0000000..66be493
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc.py	
@@ -0,0 +1,9 @@
+#!/usr/bin/python
+
+import sys
+
+from diffcmd.diffcalc_launcher import main
+
+
+if __name__ == '__main__':
+    sys.exit(main())
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/__init__.py b/script/test/diffcalc (copy)/diffcalc/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/dc/__init__.py b/script/test/diffcalc (copy)/diffcalc/dc/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/dc/common.py b/script/test/diffcalc (copy)/diffcalc/dc/common.py
new file mode 100644
index 0000000..9793f71
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/dc/common.py	
@@ -0,0 +1,24 @@
+from diffcalc.util import allnum, command, DiffcalcException
+
+
+def sim(scn, hkl):
+    """sim hkl scn -- simulates moving scannable (not all)
+    """
+    if not isinstance(hkl, (tuple, list)):
+        raise TypeError()
+
+    if not allnum(hkl):
+        raise TypeError()
+
+    try:
+        print scn.simulateMoveTo(hkl)
+    except AttributeError:
+        raise TypeError(
+                "The first argument does not support simulated moves")
+        
+def energy_to_wavelength(energy):
+    try:
+        return 12.39842 / energy
+    except ZeroDivisionError:
+        raise DiffcalcException(
+            "Cannot calculate hkl position as Energy is set to 0")
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/dc/dcvlieg.py b/script/test/diffcalc (copy)/diffcalc/dc/dcvlieg.py
new file mode 100644
index 0000000..b1fb5da
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/dc/dcvlieg.py	
@@ -0,0 +1,76 @@
+from diffcalc.dc.common import energy_to_wavelength
+
+from diffcalc import settings
+from diffcalc.hkl.vlieg.transform import VliegTransformSelector,\
+    TransformCommands, VliegPositionTransformer
+from diffcalc.dc.help import compile_extra_motion_commands_for_help
+import diffcalc.hkl.vlieg.calc
+
+
+# reload to aid testing only
+import diffcalc.ub.ub as _ub
+reload(_ub)
+from diffcalc import hardware as _hardware
+#reload(_hardware)
+import diffcalc.hkl.vlieg.hkl as _hkl
+reload(_hkl)
+
+from diffcalc.ub.ub import *  # @UnusedWildImport
+from diffcalc.hardware import *  # @UnusedWildImport
+from diffcalc.hkl.vlieg.hkl import *  # @UnusedWildImport
+from diffcalc.gdasupport.scannable.sim import sim
+
+_transform_selector = VliegTransformSelector()
+_transform_commands = TransformCommands(_transform_selector)
+_transformer = VliegPositionTransformer(settings.geometry, settings.hardware,
+                                       _transform_selector)
+
+transform = _transform_commands.transform
+transforma = _transform_commands.transforma
+transformb = _transform_commands.transformb
+transformc = _transform_commands.transformc
+
+
+on = 'on'
+off = 'off'
+auto = 'auto'
+manual = 'manual'
+    
+def hkl_to_angles(h, k, l, energy=None):
+    """Convert a given hkl vector to a set of diffractometer angles"""
+    if energy is None:
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+
+    position, params = hklcalc.hklToAngles(h, k, l, energy_to_wavelength(energy))
+    position = _transformer.transform(position)
+    angle_tuple = settings.geometry.internal_position_to_physical_angles(position)  # @UndefinedVariable
+    angle_tuple = settings.hardware.cut_angles(angle_tuple)  # @UndefinedVariable
+ 
+    return angle_tuple, params
+
+
+def angles_to_hkl(angleTuple, energy=None):
+    """Converts a set of diffractometer angles to an hkl position
+    ((h, k, l), paramDict)=angles_to_hkl(self, (a1, a2,aN), energy=None)"""
+    if energy is None:
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+
+    i_pos = settings.geometry.physical_angles_to_internal_position(angleTuple)  # @UndefinedVariable
+    return hklcalc.anglesToHkl(i_pos, energy_to_wavelength(energy))
+
+
+settings.ubcalc_strategy = diffcalc.hkl.vlieg.calc.VliegUbCalcStrategy()
+settings.angles_to_hkl_function = diffcalc.hkl.vlieg.calc.vliegAnglesToHkl       
+settings.include_sigtau = True
+
+ub_commands_for_help = _ub.commands_for_help
+
+hkl_commands_for_help = (_hkl.commands_for_help +
+                         _hardware.commands_for_help +
+                         ['Transform',
+                          transform,
+                          transforma,
+                          transformb,
+                          transformc] +
+                          compile_extra_motion_commands_for_help())
+
diff --git a/script/test/diffcalc (copy)/diffcalc/dc/dcwillmot.py b/script/test/diffcalc (copy)/diffcalc/dc/dcwillmot.py
new file mode 100644
index 0000000..7bd8a87
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/dc/dcwillmot.py	
@@ -0,0 +1,47 @@
+# This file differs from dcyou in only two places
+
+from diffcalc import settings
+from diffcalc.dc.common import energy_to_wavelength
+from diffcalc.dc.help import compile_extra_motion_commands_for_help
+import diffcalc.hkl.willmott.calc
+
+
+# reload to aid testing only
+from diffcalc.ub import ub as _ub
+reload(_ub)
+from diffcalc import hardware as _hardware
+#reload(_hardware)
+from diffcalc.hkl.you import hkl as _hkl
+reload(_hkl)
+
+from diffcalc.ub.ub import *  # @UnusedWildImport
+from diffcalc.hardware import *  # @UnusedWildImport
+from diffcalc.hkl.willmot.hkl import *  # @UnusedWildImport
+from diffcalc.gdasupport.scannable.sim import sim
+
+def hkl_to_angles(h, k, l, energy=None):
+    """Convert a given hkl vector to a set of diffractometer angles"""
+    if energy is None:
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+
+    (pos, params) = hklcalc.hklToAngles(h, k, l, energy_to_wavelength(energy))
+    angle_tuple = settings.geometry.internal_position_to_physical_angles(pos)  # @UndefinedVariable
+    angle_tuple = settings.hardware.cut_angles(angle_tuple)  # @UndefinedVariable
+
+    return angle_tuple, params
+
+def angles_to_hkl(angleTuple, energy=None):
+    """Converts a set of diffractometer angles to an hkl position
+    ((h, k, l), paramDict)=angles_to_hkl(self, (a1, a2,aN), energy=None)"""
+    if energy is None:
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+    i_pos = settings.geometry.physical_angles_to_internal_position(angleTuple)  # @UndefinedVariable
+    return hklcalc.anglesToHkl(i_pos, energy_to_wavelength(energy))
+
+settings.ubcalc_strategy = diffcalc.hkl.willmott.calc.WillmottHorizontalUbCalcStrategy()
+settings.angles_to_hkl_function = diffcalc.hkl.willmott.calc.angles_to_hkl    
+        
+
+ub_commands_for_help = _ub.commands_for_help
+
+hkl_commands_for_help = _hkl.commands_for_help + _hardware.commands_for_help + compile_extra_motion_commands_for_help()
diff --git a/script/test/diffcalc (copy)/diffcalc/dc/dcyou.py b/script/test/diffcalc (copy)/diffcalc/dc/dcyou.py
new file mode 100644
index 0000000..651c2fe
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/dc/dcyou.py	
@@ -0,0 +1,56 @@
+from diffcalc import settings
+from diffcalc.dc.common import energy_to_wavelength
+from diffcalc.dc.help import compile_extra_motion_commands_for_help
+
+import diffcalc.hkl.you.calc
+settings.ubcalc_strategy = diffcalc.hkl.you.calc.YouUbCalcStrategy()
+settings.angles_to_hkl_function = diffcalc.hkl.you.calc.youAnglesToHkl
+settings.include_reference = True
+
+# reload to aid testing only
+from diffcalc.ub import ub as _ub
+
+reload(_ub)
+from diffcalc import hardware as _hardware
+#reload(_hardware)
+from diffcalc.hkl.you import hkl as _hkl
+reload(_hkl)
+
+from diffcalc.ub.ub import *  # @UnusedWildImport
+from diffcalc.hardware import *  # @UnusedWildImport
+from diffcalc.hkl.you.hkl import *  # @UnusedWildImport
+
+
+def hkl_to_angles(h, k, l, energy=None):
+    """Convert a given hkl vector to a set of diffractometer angles
+    
+    return angle tuple and params dictionary
+    
+    """
+    if energy is None:
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+
+    (pos, params) = hklcalc.hklToAngles(h, k, l, energy_to_wavelength(energy))
+    angle_tuple = settings.geometry.internal_position_to_physical_angles(pos)  # @UndefinedVariable
+    angle_tuple = settings.hardware.cut_angles(angle_tuple)  # @UndefinedVariable
+
+    return angle_tuple, params
+
+
+def angles_to_hkl(angleTuple, energy=None):
+    """Converts a set of diffractometer angles to an hkl position
+    
+    Return hkl tuple and params dictionary
+    
+    """
+    if energy is None:
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+    i_pos = settings.geometry.physical_angles_to_internal_position(angleTuple)  # @UndefinedVariable
+    return hklcalc.anglesToHkl(i_pos, energy_to_wavelength(energy))
+
+
+
+
+
+ub_commands_for_help = _ub.commands_for_help
+hkl_commands_for_help = _hkl.commands_for_help + _hardware.commands_for_help + compile_extra_motion_commands_for_help()
diff --git a/script/test/diffcalc (copy)/diffcalc/dc/help.py b/script/test/diffcalc (copy)/diffcalc/dc/help.py
new file mode 100644
index 0000000..5d4afe6
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/dc/help.py	
@@ -0,0 +1,161 @@
+'''
+Created on 6 May 2016
+
+@author: walton
+'''
+from diffcalc import settings
+from diffcalc.gdasupport.scannable.sim import sim
+import textwrap
+from diffcalc.util import bold
+
+
+class ExternalCommand(object):
+    """Instances found in a command_list by format_command_help will
+    result in documentation for a command without there actually being one.
+    """
+    def __init__(self, docstring):
+        """Set the docstring that will be pulled off by format_command_help.
+        """
+        self.__doc__ = docstring
+        self.__name__ = ''
+
+
+WIDTH = 27
+INDENT = 3
+
+
+def format_command_help(command_list):
+
+    row_list = _command_list_to_table_cells(command_list)
+    lines = []
+    for row_cells in row_list:
+        if len(row_cells) == 1:
+            heading = row_cells[0]
+            lines.append('')
+            lines.append(bold(heading))
+            lines.append('')
+        elif len(row_cells) == 2:
+            cell1, cell2 = row_cells
+    
+            cell1_lines = textwrap.wrap(cell1, WIDTH, subsequent_indent='    ')
+            cell2_lines = textwrap.wrap(cell2, 79 - INDENT - 3 - WIDTH)
+            
+            first_line = True
+            while cell1_lines or cell2_lines:
+                line = ' ' * INDENT
+                if cell1_lines:
+                    line += cell1_lines.pop(0).ljust(WIDTH)
+                else:
+                    line += ' ' * (WIDTH)
+                line += ' : ' if first_line else '   '
+                if cell2_lines:
+                    line += cell2_lines.pop(0)
+                lines.append(line)
+                first_line = False
+
+    return '\n'.join(lines)
+
+        
+def format_commands_for_rst_table(title, command_list):
+    W1 = WIDTH  # internal width
+    W2 = 79 - W1 - 3  # internal width
+    HORIZ_LINE = '+-' + '-' * W1 + '-+-' + '-' * W2 + '-+'
+    
+    row_list = _command_list_to_table_cells(command_list)
+    
+    lines = []
+  
+    lines.append(HORIZ_LINE)  # Top line
+    for row_cells in row_list:
+        if len(row_cells) == 1:
+            lines.append('| ' + ('**' + row_cells[0] + '**').ljust(W1 + W2 + 3) + ' |')
+        
+        elif len(row_cells) == 2:
+            cmd_and_args = row_cells[0].split(' ', 1)
+            cmd = cmd_and_args[0]
+            args = cmd_and_args[1] if len(cmd_and_args) == 2 else ''
+            cell1 = '**-- %s** %s' % (cmd, args)
+            cell1_lines = textwrap.wrap(cell1, W1)  #, subsequent_indent='    ')
+            cell2_lines = textwrap.wrap(row_cells[1], W2)
+            
+            while cell1_lines or cell2_lines:
+                line = '| '
+                line += (cell1_lines.pop(0) if cell1_lines else '').ljust(W1)
+                line += ' | '
+                line += (cell2_lines.pop(0) if cell2_lines else '').ljust(W2)
+                line += ' |'
+                lines.append(line)
+        
+        else:
+            assert False
+        
+        lines.append(HORIZ_LINE)
+    return lines
+
+    
+    
+    
+                
+def _command_list_to_table_cells(command_list):
+    row_list = []
+    for obj in command_list:
+
+        if isinstance(obj, basestring):  # group heading
+            row_list.append([obj.upper()])
+
+        else:  # individual command
+            doc_before_empty_line = obj.__doc__.split('\n\n')[0]
+            doc_lines = [s.strip() for s in doc_before_empty_line.split('\n')]
+            for doc_line in doc_lines:
+                if doc_line == '':
+                    continue
+                if obj.__name__ in ('ub', 'hkl'):
+                    continue
+                name, args, desc = _split_doc_line(doc_line)
+                desc = desc.strip()
+                args = args.strip()
+                if desc and desc[-1] == '.':
+                    desc = desc[:-1]
+                
+                row_list.append([name + (' ' if args else '') + args, desc])
+    
+    return row_list
+    
+
+def _split_doc_line(docLine):
+    name, _, right = docLine.partition(' ')
+    args, _, desc = right.partition('-- ')
+    return name, args, desc
+
+
+def compile_extra_motion_commands_for_help():
+    
+    _hwname = settings.hardware.name  # @UndefinedVariable
+    _angles = ', '.join(settings.hardware.get_axes_names())  # @UndefinedVariable
+    
+    commands = []
+        
+    commands.append('Motion')
+    commands.append(sim)
+    commands.append(ExternalCommand(
+        '%(_hwname)s -- show Eularian position' % vars()))
+    commands.append(ExternalCommand(
+        'pos %(_hwname)s [%(_angles)s]  -- move to Eularian position'
+        '(None holds an axis still)' % vars()))
+    commands.append(ExternalCommand(
+        'sim %(_hwname)s [%(_angles)s] -- simulate move to Eulerian position'
+        '%(_hwname)s' % vars()))
+    
+    commands.append(ExternalCommand(
+        'hkl -- show hkl position'))
+    commands.append(ExternalCommand(
+        'pos hkl [h k l] -- move to hkl position'))
+    commands.append(ExternalCommand(
+        'pos {h | k | l} val -- move h, k or l to val'))
+    commands.append(ExternalCommand(
+        'sim hkl [h k l] -- simulate move to hkl position'))
+    
+#     if engine_name != 'vlieg':
+#         pass
+#         # TODO: remove sigtau command and 'Surface' string
+    return commands
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/__init__.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/__init__.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/command.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/command.py
new file mode 100644
index 0000000..d6e7fc5
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/command.py	
@@ -0,0 +1,322 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+#try:
+#    from gda.device import Scannable
+#except ImportError:
+#    from diffcalc.gdasupport.minigda.scannable import Scannable
+from diffcalc.gdasupport.minigda.scannable import Scannable
+from diffcalc.util import getMessageFromException, allnum, bold
+import math
+
+
+ROOT_NAMESPACE_DICT = {}
+
+class Pos(object):
+
+    def __init__(self):
+        self.__name__ = 'pos'
+
+    def __call__(self, *posargs):
+        if len(posargs) == 0:
+
+            keys = dict(ROOT_NAMESPACE_DICT).keys()
+            keys.sort()
+            for key in keys:
+                val = ROOT_NAMESPACE_DICT[key]
+                if isinstance(val, Scannable):
+                    print self.posReturningReport(val)
+        else:
+            print self.posReturningReport(*posargs)
+
+    def posReturningReport(self, *posargs):
+        # report position of this scannable
+        if len(posargs) == 1:
+            scannable = posargs[0]
+            self._assert_scannable(scannable)
+            return self._generatePositionReport(scannable)
+
+        # Move the scannable and report
+        elif len(posargs) == 2:
+            scannable = posargs[0]
+            self._assert_scannable(scannable)
+            # Move it
+            scannable.asynchronousMoveTo(posargs[1])
+            # TODO: minigda assumes all moves complete instantly, so no need
+            # yet to check the move is complete
+            return self._generatePositionReport(scannable)
+
+        else:
+            raise ValueError(
+                "Invlaid arguements: 'pos [ scannable [ value ] ]'")
+
+    def _assert_scannable(self, obj):
+        if not isinstance(obj, Scannable):
+                raise TypeError(
+                    "The first argument to the pos command must be scannable. "
+                    "Not: " + str(type(obj)))
+
+    def _generatePositionReport(self, scannable):
+        fieldNames = (tuple(scannable.getInputNames()) +
+                      tuple(scannable.getExtraNames()))
+        # All scannables
+        result = "%s:" % scannable.getName()
+        result = result.ljust(10)
+        try:
+            pos = scannable.getPosition()
+        except Exception, e:
+            return result + "Error: %s" % getMessageFromException(e)
+        if pos is None:
+            return result + "---"
+        # Single field scannable:
+        if len(fieldNames) == 1:
+            try:
+                result += "%s" % scannable.formatPositionFields(pos)[0]
+            except AttributeError:
+                result += str(scannable())
+        # Multi field scannable:
+        else:
+            try:
+                formatted = scannable.formatPositionFields(pos)
+                for name, formattedValue in zip(fieldNames, formatted):
+                    result += "%s: %s " % (name, formattedValue)
+            except AttributeError:
+                result += str(scannable())
+
+        return result
+
+
+class ScanDataHandler:
+    def __init__(self):
+        self.scannables = None
+
+    def callAtScanStart(self, scannables):
+        pass
+
+    def callWithScanPoint(self, PositionDictIndexedByScannable):
+        pass
+
+    def callAtScanEnd(self):
+        pass
+
+
+class ScanDataPrinter(ScanDataHandler):
+
+    def __init__(self):
+        self.first_point_printed = False
+        self.widths = []
+        self.scannables = []
+
+    def callAtScanStart(self, scannables):
+        self.first_point_printed = False
+        self.scannables = scannables
+
+    def print_first_point(self, position_dict):
+        # also sets self.widths
+        header_strings = []
+        for scn in self.scannables:
+            field_names = list(scn.getInputNames()) + list(scn.getExtraNames())
+            if len(field_names) == 1:
+                header_strings.append(scn.getName())
+            else:
+                for field_name in field_names:
+                    header_strings.append(field_name)
+
+        first_row_strings = []
+        for scn in self.scannables:
+            pos = position_dict[scn]
+            first_row_strings.extend(scn.formatPositionFields(pos))
+
+        self.widths = []
+        for header, pos_string in zip(header_strings, first_row_strings):
+            self.widths.append(max(len(header), len(pos_string)))
+
+        header_cells = []
+        for heading, width in zip(header_strings, self.widths):
+            header_cells.append(heading.rjust(width))
+
+        underline_cells = ['-' * w for w in self.widths]
+
+        first_row_cells = []
+        for pos, width in zip(first_row_strings, self.widths):
+            first_row_cells.append(pos.rjust(width))
+
+        #table_width = sum(self.widths) + len(self.widths * 2) - 2
+        lines = []
+        #lines.append('=' * table_width)
+        lines.append(bold('  '.join(header_cells)))
+        lines.append('  '.join(underline_cells))
+        lines.append('  '.join(first_row_cells))
+        print '\n'.join(lines)
+
+    def callWithScanPoint(self, position_dict):
+        if not self.first_point_printed:
+            self.print_first_point(position_dict)
+            self.first_point_printed = True
+        else:
+            row_strings = []
+            for scn in self.scannables:
+                pos = position_dict[scn]
+                row_strings.extend(scn.formatPositionFields(pos))
+
+            row_cells = []
+            for pos, width in zip(row_strings, self.widths):
+                row_cells.append(pos.rjust(width))
+
+            print '  '.join(row_cells)
+
+    def callAtScanEnd(self):
+        #table_width = sum(self.widths) + len(self.widths * 2) - 2
+        #print '=' * table_width
+        pass
+
+
+class Scan(object):
+    class Group:
+        def __init__(self, scannable):
+            self.scannable = scannable
+            self.args = []
+
+        def __cmp__(self, other):
+            return(self.scannable.getLevel() - other.scannable.getLevel())
+
+        def __repr__(self):
+            return "Group(%s, %s)" % (self.scannable.getName(), str(self.args))
+
+        def shouldTriggerLoop(self):
+            return len(self.args) == 3
+
+    def __init__(self, scanDataHandlers):
+        # scanDataHandlers should be list
+        if type(scanDataHandlers) not in (tuple, list):
+            scanDataHandlers = (scanDataHandlers,)
+        self.dataHandlers = scanDataHandlers
+
+    def __call__(self, *scanargs):
+        groups = self._parseScanArgsIntoScannableArgGroups(scanargs)
+        groups = self._reorderInnerGroupsAccordingToLevel(groups)
+        # Configure data handlers for a new scan
+        for handler in self.dataHandlers: handler.callAtScanStart(
+            [grp.scannable for grp in groups])
+        # Perform the scan
+        self._performScan(groups, currentRecursionLevel=0)
+        # Inform data handlers of scan completion
+        for handler in self.dataHandlers: handler.callAtScanEnd()
+
+    def _parseScanArgsIntoScannableArgGroups(self, scanargs):
+        """
+        -> [ Group(scnA, (a1, a2, a2)), Group((scnB), (b1)), ...
+        ... Group((scnC),()), Group((scnD),(d1))]
+        """
+        result = []
+        if not isinstance(scanargs[0], Scannable):
+            raise TypeError("First scan argument must be a scannable")
+
+        # Parse out scannables followed by non-scannable args
+        for arg in scanargs:
+            if isinstance(arg, Scannable):
+                result.append(Scan.Group(arg))
+            else:
+                result[-1].args.append(arg)
+        return result
+
+    def _reorderInnerGroupsAccordingToLevel(self, groups):
+        # Find the first group not to trigger a loop
+        for idx, group in enumerate(groups):
+            if not group.shouldTriggerLoop():
+                break
+        latter = groups[idx:]; latter.sort() # Horrible hack not needed in python 3!
+        return groups[:idx] + latter
+
+    def _performScan(self, groups, currentRecursionLevel):
+        # groups[currentRecursionLevel:] will start with either:
+        #  a) A loop triggering group
+        #  b) A number (possibly 0) of non-loop triggering groups
+        unprocessedGroups = groups[currentRecursionLevel:]
+
+        # 1) If first remaining group should trigger a loop, perform this loop,
+        #    recursively calling this method on the remaining groups
+        if len(unprocessedGroups) > 0:
+            first = unprocessedGroups[0]
+            # If groups starts with a request to loop:
+            if first.shouldTriggerLoop():
+                posList = self._frange(first.args[0], first.args[1], first.args[2])
+                for pos in posList:
+                    first.scannable.asynchronousMoveTo(pos)
+                    # TODO: Should wait. minigda assumes all moves complete immediately
+                    self._performScan(groups, currentRecursionLevel + 1)
+                return
+
+        # 2) Move all non-loop triggering groups (may be zero)
+        self._moveNonLoopTriggeringGroups(unprocessedGroups)
+
+        # 3) Sample position of all scannables
+        posDict = self._samplePositionsOfAllScannables(groups)
+
+        # 4) Inform the data handlers that this point has been recorded
+        for handler in self.dataHandlers: handler.callWithScanPoint(posDict)
+
+    def _moveNonLoopTriggeringGroups(self, groups):
+        # TODO: Should wait. minigda assumes all moves complete immediately. groups could be zero lengthed.
+        for grp in groups:
+            if len(grp.args) == 0:
+                pass
+            elif len(grp.args) == 1:
+                grp.scannable.asynchronousMoveTo(grp.args[0])
+            elif len(grp.args) == 2:
+                raise Exception("Scannables followed by two args not supported by minigda's scan command ")
+            else:
+                raise Exception("Scannable: %s args%s" % (grp.scannable, str(grp.args)))
+
+    def _samplePositionsOfAllScannables(self, groups):
+        posDict = {}
+        for grp in groups:
+            posDict[grp.scannable] = grp.scannable.getPosition()
+        return posDict
+
+    def _frange(self, limit1, limit2, increment):
+        """Range function that accepts floats (and integers).
+        """
+#        limit1 = float(limit1)
+#        limit2 = float(limit2)
+        try:
+            increment = float(increment)
+        except TypeError:
+            raise TypeError(
+                "Only scaler values are supported, not GDA format vectors.")
+        count = int(math.ceil(((limit2 - limit1) + increment / 100.) / increment))
+        result = []
+        for n in range(count):
+            result.append(limit1 + n * increment)
+        return result
+
+
+def sim(scn, hkl):
+    """sim hkl scn -- simulates moving scannable (not all)
+    """
+    if not isinstance(hkl, (tuple, list)):
+        raise TypeError()
+
+    if not allnum(hkl):
+        raise TypeError()
+
+    try:
+        print scn.simulateMoveTo(hkl)
+    except AttributeError:
+        raise TypeError(
+                "The first argument does not support simulated moves")
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/scannable.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/scannable.py
new file mode 100644
index 0000000..f6f9926
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/minigda/scannable.py	
@@ -0,0 +1,511 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import time
+
+try:
+    from gda.device.scannable import ScannableBase
+except ImportError:
+    class Scannable(object):
+        pass
+    
+    class ScannableBase(Scannable):
+        """Implemtation of a subset of OpenGDA's Scannable interface
+        """
+    
+        level = 5
+        inputNames = []
+        extraNames = []
+        outputFormat = []
+    
+        def isBusy(self):
+            raise NotImplementedError()
+    
+        def rawGetPosition(self):
+            raise NotImplementedError()
+    
+        def rawAsynchronousMoveTo(self, newpos):
+            raise NotImplementedError()
+    
+        def waitWhileBusy(self):
+            while self.isBusy():
+                time.sleep(.1)
+    
+        def getPosition(self):
+            return self.rawGetPosition()
+    
+        def asynchronousMoveTo(self, newpos):
+            self.rawAsynchronousMoveTo(newpos)
+    
+        def atScanStart(self):
+            pass
+    
+        def atScanEnd(self):
+            pass
+    
+        def atCommandFailure(self):
+            pass
+    
+    ###
+    
+        def __repr__(self):
+            pos = self.getPosition()
+            formattedValues = self.formatPositionFields(pos)
+            if len(tuple(self.getInputNames()) + tuple(self.getExtraNames())) > 1:
+                result = self.getName() + ': '
+            else:
+                result = ''
+    
+            names = tuple(self.getInputNames()) + tuple(self.getExtraNames())
+            for name, val in zip(names, formattedValues):
+                result += ' ' + name + ': ' + val
+            return result
+    ###
+    
+        def formatPositionFields(self, pos):
+            """Returns position as array of formatted strings"""
+            # Make sure pos is a tuple or list
+            if type(pos) not in (tuple, list):
+                pos = tuple([pos])
+    
+            # Sanity check
+            if len(pos) != len(self.getOutputFormat()):
+                raise Exception(
+                    "In scannable '%s':number of position fields differs from "
+                    "number format strings specified" % self.getName())
+    
+            result = []
+            for field, format in zip(pos, self.getOutputFormat()):
+                if field is None:
+                    result.append('???')
+                else:
+                    s = (format % field)
+    ##                if width!=None:
+    ##                s = s.ljust(width)
+                    result.append(s)
+    
+            return result
+    
+        def getName(self):
+            return self.name
+    
+        def setName(self, value):
+            self.name = value
+    
+        def getLevel(self):
+            return self.level
+    
+        def setLevel(self, value):
+            self.level = value
+    
+        def getInputNames(self):
+            return self.inputNames
+    
+        def setInputNames(self, value):
+            self.inputNames = value
+    
+        def getExtraNames(self):
+            return self.extraNames
+    
+        def setExtraNames(self, value):
+            self.extraNames = value
+    
+        def getOutputFormat(self):
+            return self.outputFormat
+    
+        def setOutputFormat(self, value):
+            if type(value) not in (tuple, list):
+                raise TypeError(
+                    "%s.setOutputFormat() expects tuple or list; not %s" %
+                    (self.getName(), str(type(value))))
+            self.outputFormat = value
+    
+        def __call__(self, newpos=None):
+            if newpos is None:
+                return self.getPosition()
+            self.asynchronousMoveTo(newpos)
+    
+    class ScannableAdapter(Scannable):
+        '''Wrap up a Scannable and give it a new name and optionally an offset
+        (added to the delegate when reading up and subtracting when setting down
+        '''
+        
+        def __init__(self, delegate_scn, name, offset=0):
+            assert len(delegate_scn.getInputNames()) == 1
+            assert len(delegate_scn.getExtraNames()) == 0
+            self.delegate_scn = delegate_scn
+            self.name = name
+            self.offset = offset
+                   
+        def __getattr__(self, name):
+            return getattr(self.delegate_scn, name)
+        
+        def getName(self):
+            return self.name
+        
+        def getInputNames(self):
+            return [self.name]
+        
+        def getPosition(self):
+            return self.delegate_scn.getPosition() + self.offset
+        
+        def asynchronousMoveTo(self, newpos):
+            self.delegate_scn.asynchronousMoveTo(newpos - self.offset)
+            
+        def __repr__(self):
+            pos = self.getPosition()
+            formatted_values = self.delegate_scn.formatPositionFields(pos)  
+            return self.name + ': ' + formatted_values[0] + ' ' + self.get_hint()
+        
+        def get_hint(self):
+            if self.offset:
+                offset_hint = ' + ' if self.offset >= 0 else ' - '
+                offset_hint += str(self.offset)
+            else:
+                offset_hint = ''
+            return '(%s%s)' % (self.delegate_scn.name, offset_hint)
+        
+        def __call__(self, newpos=None):
+            if newpos is None:
+                return self.getPosition()
+            self.asynchronousMoveTo(newpos)
+
+class SingleFieldDummyScannable(ScannableBase):
+
+    def __init__(self, name, initial_position=0.):
+        self.name = name
+        self.inputNames = [name]
+        self.outputFormat = ['% 6.4f']
+        self.level = 3
+        self._current_position = float(initial_position)
+
+    def isBusy(self):
+        return False
+
+    def waitWhileBusy(self):
+        return
+
+    def asynchronousMoveTo(self, new_position):
+        self._current_position = float(new_position)
+
+    def getPosition(self):
+        return self._current_position
+
+
+class DummyPD(SingleFieldDummyScannable):
+    """For compatability with the gda's dummy_pd module"""
+    pass
+
+
+class MultiInputExtraFieldsDummyScannable(ScannableBase):
+    '''Multi input Dummy PD Class supporting input and extra fields'''
+    def __init__(self, name, inputNames, extraNames):
+        self.setName(name)
+        self.setInputNames(inputNames)
+        self.setExtraNames(extraNames)
+        self.setOutputFormat(['%6.4f'] * (len(inputNames) + len(extraNames)))
+        self.setLevel(3)
+        self.currentposition = [0.0] * len(inputNames)
+
+    def isBusy(self):
+        return 0
+
+    def asynchronousMoveTo(self, new_position):
+        if type(new_position) == type(1) or type(new_position) == type(1.0):
+            new_position = [new_position]
+            msg = "Wrong new_position size"
+        assert len(new_position) == len(self.currentposition), msg
+        for i in range(len(new_position)):
+            if new_position[i] != None:
+                self.currentposition[i] = float(new_position[i])
+
+    def getPosition(self):
+        extraValues = range(100, 100 + (len(self.getExtraNames())))
+        return self.currentposition + map(float, extraValues)
+
+
+class ZeroInputExtraFieldsDummyScannable(ScannableBase):
+    '''Zero input/extra field dummy pd
+    '''
+    def __init__(self, name):
+        self.setName(name)
+        self.setInputNames([])
+        self.setOutputFormat([])
+
+    def isBusy(self):
+        return 0
+
+    def asynchronousMoveTo(self, new_position):
+        pass
+
+    def getPosition(self):
+        pass
+
+
+class ScannableGroup(ScannableBase):
+    """wraps up motors. Simulates motors if non given."""
+
+    def __init__(self, name, motorList):
+
+        self.setName(name)
+        # Set input format
+        motorNames = []
+        for scn in motorList:
+            motorNames.append(scn.getName())
+        self.setInputNames(motorNames)
+        # Set output format
+        format = []
+        for motor in motorList:
+            format.append(motor.getOutputFormat()[0])
+        self.setOutputFormat(format)
+        self.__motors = motorList
+
+    def asynchronousMoveTo(self, position):
+        # if input has any Nones, then replace these with the current positions
+        if None in position:
+            position = list(position)
+            current = self.getPosition()
+            for idx, val in enumerate(position):
+                if val is None:
+                    position[idx] = current[idx]
+
+        for scn, pos in zip(self.__motors, position):
+            scn.asynchronousMoveTo(pos)
+
+    def getPosition(self):
+        return [scn.getPosition() for scn in self.__motors]
+
+    def isBusy(self):
+        for scn in self.__motors:
+            if scn.isBusy():
+                return True
+        return False
+
+    def configure(self):
+        pass
+
+
+class ScannableMotionWithScannableFieldsBase(ScannableBase):
+    '''
+    This extended version of ScannableMotionBase contains a
+    completeInstantiation() method which adds a dictionary of
+    MotionScannableParts to an instance. Each part allows one of the
+    instances fields to be interacted with like it itself is a scannable.
+    Fields are dynamically added to the instance linking to these parts
+    allowing dotted access from Jython.  They may also be accessed using
+    Jython container access methods (via the __getitem__() method). To acess
+    them from Jave use the getComponent(name) method.
+
+    When moving a part (via either a pos or scan command), the part calls
+    the parent to perform the actual task.  The parts asynchronousMoveto
+    command will call the parent with a list of None values except for the
+    field it represents which will be passed the desired position value.
+
+    The asynchronousMoveTo method in class that inherats from this base
+    class then must handle these Nones.  In some cases the method may
+    actually be able to move the underlying system assoiciated with one
+    field individually from others. If this is not possible the best
+    behaviour may be to simply not support this beahviour and exception or
+    alternatively to substitute the None values with actual current position
+    of parent's scannables associated fields.
+
+    ScannableMotionBaseWithMemory() inherats from this calss and provides a
+    solution useful for some scenarious: it keeps track of the last position
+    moved to, and replaces the Nones in an asynchronousMoveTo request with
+    these values. There are a number of dangers associated with this which
+    are addressed in that class's documentation, but it provides a way to
+    move one axis within a group of non-orthogonal axis while keeping the
+    others still.
+    '''
+    childrenDict = {}
+    numInputFields = None
+    numExtraFields = None
+
+    def completeInstantiation(self):
+        '''This method should be called at the end of all user defined
+        consructors'''
+        # self.validate()
+        self.numInputFields = len(self.getInputNames())
+        self.numExtraFields = len(self.getExtraNames())
+        self.addScannableParts()
+        self.autoCompletePartialMoveToTargets = False
+        self.positionAtScanStart = None
+
+    def setAutoCompletePartialMoveToTargets(self, b):
+        self.autoCompletePartialMoveToTargets = b
+
+    def atScanStart(self):
+        self.positionAtScanStart = self.getPosition()
+
+    def atCommandFailure(self):
+        self.positionAtScanStart = None
+
+    def atScanEnd(self):
+        self.positionAtScanStart = None
+
+###
+
+    def __repr__(self):
+        pos = self.getPosition()
+        formattedValues = self.formatPositionFields(pos)
+        if len(tuple(self.getInputNames()) + tuple(self.getExtraNames())) > 1:
+            result = self.getName() + ': '
+        else:
+            result = ''
+
+        names = tuple(self.getInputNames()) + tuple(self.getExtraNames())
+        for name, val in zip(names, formattedValues):
+            result += ' ' + name + ': ' + val
+        return result
+###
+
+    def formatPositionFields(self, pos):
+        """Returns position as array of formatted strings"""
+        # Make sure pos is a tuple or list
+        if type(pos) not in (tuple, list):
+            pos = tuple([pos])
+
+        # Sanity check
+        if len(pos) != len(self.getOutputFormat()):
+            raise Exception(
+                "In scannable '%s':number of position fields differs from "
+                "number format strings specified" % self.getName())
+
+        result = []
+        for field, format in zip(pos, self.getOutputFormat()):
+            if field is None:
+                result.append('???')
+            else:
+                s = (format % field)
+##                if width!=None:
+##                s = s.ljust(width)
+                result.append(s)
+
+        return result
+
+###
+    
+    def addScannableParts(self):
+        '''
+        Creates an array of MotionScannableParts each of which allows access to
+        the scannable's fields. See this class's documentation for more info.
+        '''
+        self.childrenDict = {}
+        # Add parts to access the input fields
+        for index in range(len(self.getInputNames())):
+            scannableName = self.getInputNames()[index]
+            self.childrenDict[scannableName] = self.MotionScannablePart(
+                scannableName, index, self, isInputField=1)
+
+        # Add parts to access the extra fields
+        for index in range(len(self.getExtraNames())):
+            scannableName = self.getExtraNames()[index]
+            self.childrenDict[scannableName] = self.MotionScannablePart(
+                scannableName, index + len(self.getInputNames()),
+                self, isInputField=0)
+
+    def asynchronousMoveTo(self, newpos):
+        if self.autoCompletePartialMoveToTargets:
+            newpos = self.completePosition(newpos)
+        ScannableBase.asynchronousMoveTo(self, newpos)
+
+    def completePosition(self, position):
+        '''
+        If position contains any null or None values, these are replaced with
+        the corresponding fields from the scannables current position and then
+        returned.'''
+        # Just return position if it does not need padding
+        if None not in position:
+            return position
+        if self.positionAtScanStart is not None:
+            basePosition = self.positionAtScanStart
+        else:
+            basePosition = self.getPosition()[:self.numInputFields]
+        for i in range(self.numInputFields):
+            if position[i] is None:
+                position[i] = basePosition[i]
+        return position
+
+    def __getattr__(self, name):
+        try:
+            return self.childrenDict[name]
+        except:
+            raise AttributeError("No child named:" + name)
+
+    def __getitem__(self, key):
+        '''Provides container like access from Jython'''
+        return self.childrenDict[key]
+
+    def getPart(self, name):
+        '''Returns the a compnent scannable'''
+        return self.childrenDict[name]
+
+    class MotionScannablePart(ScannableBase):
+        '''
+        A scannable to be placed in the parent's childrenDict that allows
+        access to the parent's individual fields.'''
+
+        def __init__(self, scannableName, index, parentScannable,
+                     isInputField):
+            self.setName(scannableName)
+            if isInputField:
+                self.setInputNames([scannableName])
+            else:
+                self.setExtraNames([scannableName])
+            self.index = index
+            self.parentScannable = parentScannable
+            self.setOutputFormat(
+                [self.parentScannable.getOutputFormat()[index]])
+
+        def isBusy(self):
+            return self.parentScannable.isBusy()
+
+        def asynchronousMoveTo(self, new_position):
+            if self.parentScannable.isBusy():
+                raise Exception(
+                    self.parentScannable.getName() + "." + self.getName() +
+                    " cannot be moved because " +
+                    self.parentScannable.getName() + " is already moving")
+
+            toMoveTo = [None] * len(self.parentScannable.getInputNames())
+            toMoveTo[self.index] = new_position
+            self.parentScannable.asynchronousMoveTo(toMoveTo)
+            
+        def moveTo(self, new_position):
+            self.asynchronousMoveTo(new_position)
+            self.waitWhileBusy()
+
+        def getPosition(self):
+            return self.parentScannable.getPosition()[self.index]
+
+        def __str__(self):
+            return self.__repr__()
+
+        def __repr__(self):
+            # Get the name of this field
+            # (assume its an input field first and correct if wrong)
+            name = self.getInputNames()[0]
+
+            if name == 'value':
+                name = self.getExtraNames()[0]
+            parentName = self.parentScannable.getName()
+            return parentName + "." + name + " : " + str(self.getPosition())
+
+
+    
+        
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/__init__.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/base.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/base.py
new file mode 100644
index 0000000..dfa3182
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/base.py	
@@ -0,0 +1,62 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+try:
+    from gda.device.scannable import PseudoDevice
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import \
+        ScannableBase as PseudoDevice
+
+
+class ScannableGroup(PseudoDevice):
+
+    def __init__(self, name, motorList):
+
+        self.setName(name)
+        # Set input format
+        motorNames = []
+        for scn in motorList:
+            motorNames.append(scn.getName())
+        self.setInputNames(motorNames)
+        # Set output format
+        format = []
+        for motor in motorList:
+            format.append(motor.getOutputFormat()[0])
+        self.setOutputFormat(format)
+        self.__motors = motorList
+
+    def asynchronousMoveTo(self, position):
+        # if input has any Nones, then replace these with the current positions
+        if None in position:
+            position = list(position)
+            current = self.getPosition()
+            for idx, val in enumerate(position):
+                if val is None:
+                    position[idx] = current[idx]
+
+        for scn, pos in zip(self.__motors, position):
+            scn.asynchronousMoveTo(pos)
+
+    def getPosition(self):
+        return [scn.getPosition() for scn in self.__motors]
+
+    def isBusy(self):
+        for scn in self.__motors:
+            if scn.isBusy():
+                return True
+        return False
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/diffractometer.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/diffractometer.py
new file mode 100644
index 0000000..1d1b993
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/diffractometer.py	
@@ -0,0 +1,126 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+try:
+    from gda.device.scannable import ScannableMotionBase
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import \
+        ScannableBase as ScannableMotionBase
+
+from diffcalc.util import getMessageFromException
+
+# TODO: Split into a base class when making other scannables
+
+
+class DiffractometerScannableGroup(ScannableMotionBase):
+    """"
+    Wraps up a scannableGroup of axis to tweak the way the resulting
+    object is displayed and to add a simulate move to method.
+
+    The scannable group should have the same geometry as that expected
+    by the diffractometer hardware geometry used in the diffraction
+    calculator.
+
+    The optional parameter slaveDriver can be used to provide a
+    slave_driver. This is useful for triggering a move of an incidental
+    axis whose position depends on that of the diffractometer, but whose
+    position need not be included in the DiffractometerScannableGroup
+    itself. This parameter is exposed as a field and can be set or
+    cleared to null at will without effecting the core calculation code.
+    """
+
+    def __init__(self, name, diffcalc_module, scannableGroup,
+                 slave_driver=None, hint_generator=None):
+        # if motorList is None, will create a dummy __group
+        self.diffcalc_module = diffcalc_module
+        self.__group = scannableGroup
+        self.slave_driver = slave_driver
+        self.setName(name)
+        self.hint_generator = hint_generator
+
+    def getInputNames(self):
+        return self.__group.getInputNames()
+
+    def getExtraNames(self):
+        if self.slave_driver is None:
+            return []
+        else:
+            return self.slave_driver.getScannableNames()
+
+    def getOutputFormat(self):
+        if self.slave_driver is None:
+            slave_formats = []
+        else:
+            slave_formats = self.slave_driver.getScannableNames()
+        return list(self.__group.getOutputFormat()) + slave_formats
+
+    def asynchronousMoveTo(self, position):
+        self.__group.asynchronousMoveTo(position)
+        if self.slave_driver is not None:
+            self.slave_driver.triggerAsynchronousMove(position)
+
+    def getPosition(self):
+        if self.slave_driver is None:
+            slave_positions = []
+        else:
+            slave_positions = self.slave_driver.getPositions()
+        return list(self.__group.getPosition()) + list(slave_positions)
+
+    def isBusy(self):
+        if self.slave_driver is None:
+            return self.__group.isBusy()
+        else:
+            return self.__group.isBusy() or self.slave_driver.isBusy()
+
+    def waitWhileBusy(self):
+        self.__group.waitWhileBusy()
+        if self.slave_driver is not None:
+            self.slave_driver.waitWhileBusy()
+
+    def simulateMoveTo(self, pos):
+        if len(pos) != len(self.getInputNames()):
+            raise ValueError('Wrong number of inputs')
+        try:
+            (hkl, params) = self.diffcalc_module.angles_to_hkl(pos)
+        except Exception, e:
+            return "Error: %s" % getMessageFromException(e)
+        width = max(len(k) for k in params)
+
+        lines = (['  ' + 'hkl'.rjust(width) + ' : % 9.4f  %.4f  %.4f' %
+                  (hkl[0], hkl[1], hkl[2])])
+        lines[-1] = lines[-1] + '\n'
+        fmt = '  %' + str(width) + 's : % 9.4f'
+        for k in sorted(params):
+            lines.append(fmt % (k, params[k]))
+        return '\n'.join(lines)
+
+    def __repr__(self):
+        position = self.getPosition()
+        names = list(self.getInputNames()) + list(self.getExtraNames())
+        if self.hint_generator is None:
+            hint_list = [''] * len(self.getInputNames())
+        else:
+            hint_list = self.hint_generator()
+        
+        lines = [self.name + ':']
+        width = max(len(k) for k in names)
+        fmt = '  %' + str(width) + 's : % 9.4f   %s'
+        for name, pos, hint in zip(names, position, hint_list):
+            lines.append(fmt % (name, pos, hint))
+        lines[len(self.getInputNames())] += '\n'
+        return '\n'.join(lines)
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/hkl.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/hkl.py
new file mode 100644
index 0000000..12376d2
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/hkl.py	
@@ -0,0 +1,135 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+import platform
+
+DEBUG = False
+
+try:
+    from gda.device.scannable.scannablegroup import \
+        ScannableMotionWithScannableFieldsBase
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import \
+        ScannableMotionWithScannableFieldsBase
+
+from diffcalc.util import getMessageFromException, DiffcalcException
+
+
+class _DynamicDocstringMetaclass(type):
+
+    def _get_doc(self):
+        return Hkl.dynamic_docstring
+
+    __doc__ = property(_get_doc)  # @ReservedAssignment
+
+
+class Hkl(ScannableMotionWithScannableFieldsBase):
+    
+    if platform.system() != 'Java':
+        __metaclass__ = _DynamicDocstringMetaclass  # TODO: Removed to fix Jython
+
+    dynamic_docstring = 'Hkl Scannable'
+
+    def _get_doc(self):
+        return Hkl.dynamic_docstring
+
+    __doc__ = property(_get_doc)  # @ReservedAssignment
+
+    def __init__(self, name, diffractometerObject, diffcalcObject,
+                 virtualAnglesToReport=None):
+        self.diffhw = diffractometerObject
+        self._diffcalc = diffcalcObject
+        if type(virtualAnglesToReport) is str:
+            virtualAnglesToReport = (virtualAnglesToReport,)
+        self.vAngleNames = virtualAnglesToReport
+
+        self.setName(name)
+        self.setInputNames(['h', 'k', 'l'])
+        self.setOutputFormat(['%7.5f'] * 3)
+        if self.vAngleNames:
+            self.setExtraNames(self.vAngleNames)
+            self.setOutputFormat(['%7.5f'] * (3 + len(self.vAngleNames)))
+
+        self.completeInstantiation()
+        self.setAutoCompletePartialMoveToTargets(True)
+        self.dynamic_class_doc = 'Hkl Scannable xyz'
+
+    def rawAsynchronousMoveTo(self, hkl):
+        if len(hkl) != 3: raise ValueError('Hkl device expects three inputs')
+        try:
+            (pos, _) = self._diffcalc.hkl_to_angles(hkl[0], hkl[1], hkl[2])
+        except DiffcalcException, e:
+            if DEBUG:
+                raise
+            else:
+                raise DiffcalcException(e.message)
+        self.diffhw.asynchronousMoveTo(pos)
+
+    def rawGetPosition(self):
+        pos = self.diffhw.getPosition()  # a tuple
+        (hkl , params) = self._diffcalc.angles_to_hkl(pos)
+        result = list(hkl)
+        if self.vAngleNames:
+            for vAngleName in self.vAngleNames:
+                result.append(params[vAngleName])
+        return result
+
+    def getFieldPosition(self, i):
+        return self.getPosition()[i]
+
+    def isBusy(self):
+        return self.diffhw.isBusy()
+
+    def waitWhileBusy(self):
+        return self.diffhw.waitWhileBusy()
+
+    def simulateMoveTo(self, hkl):
+        if type(hkl) not in (list, tuple):
+            raise ValueError('Hkl device expects three inputs')
+        if len(hkl) != 3:
+            raise ValueError('Hkl device expects three inputs')
+        (pos, params) = self._diffcalc.hkl_to_angles(hkl[0], hkl[1], hkl[2])
+
+        width = max(len(k) for k in (params.keys() + list(self.diffhw.getInputNames())))
+        fmt = '  %' + str(width) + 's : % 9.4f'
+
+        lines = [self.diffhw.getName() + ' would move to:']
+        for idx, name in enumerate(self.diffhw.getInputNames()):
+            lines.append(fmt % (name, pos[idx]))
+        lines[-1] = lines[-1] + '\n'
+        for k in sorted(params):
+            lines.append(fmt % (k, params[k]))
+        return '\n'.join(lines)
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        lines = ['hkl:']
+        pos = self.diffhw.getPosition()
+        try:
+            (hkl, params) = self._diffcalc.angles_to_hkl(pos)
+        except Exception, e:
+            return "<hkl: %s>" % getMessageFromException(e)
+
+        width = max(len(k) for k in params)
+        lines.append('  ' + 'hkl'.rjust(width) + ' : %9.4f  %.4f  %.4f' % (hkl[0], hkl[1], hkl[2]))
+        lines[-1] = lines[-1] + '\n'
+        fmt = '  %' + str(width) + 's : % 9.4f'
+        for k in sorted(params):
+            lines.append(fmt % (k, params[k]))
+        return '\n'.join(lines)
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/mock.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/mock.py
new file mode 100644
index 0000000..13871da
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/mock.py	
@@ -0,0 +1,47 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+try:
+    from gda.device.scannable import ScannableMotionBase
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import \
+        ScannableBase as ScannableMotionBase
+
+
+class MockMotor(ScannableMotionBase):
+
+    def __init__(self, name='mock'):
+        self.pos = 0.0
+        self._busy = False
+        self.name = name
+
+    def asynchronousMoveTo(self, pos):
+        self._busy = True
+        self.pos = float(pos)
+
+    def getPosition(self):
+        return self.pos
+
+    def isBusy(self):
+        return self._busy
+
+    def makeNotBusy(self):
+        self._busy = False
+
+    def getOutputFormat(self):
+        return ['%f']
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/parameter.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/parameter.py
new file mode 100644
index 0000000..a08e95c
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/parameter.py	
@@ -0,0 +1,45 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+try:
+    from gda.device.scannable import ScannableMotionBase
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import \
+        ScannableBase as ScannableMotionBase
+
+
+class DiffractionCalculatorParameter(ScannableMotionBase):
+
+    def __init__(self, name, parameterName, parameter_manager):
+
+        self.parameter_manager = parameter_manager
+        self.parameterName = parameterName
+
+        self.setName(name)
+        self.setInputNames([parameterName])
+        self.setOutputFormat(['%5.5f'])
+        self.setLevel(3)
+
+    def asynchronousMoveTo(self, value):
+        self.parameter_manager.set_constraint(self.parameterName, value)
+
+    def getPosition(self):
+        return self.parameter_manager.get_constraint(self.parameterName)
+
+    def isBusy(self):
+        return False
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/sim.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/sim.py
new file mode 100644
index 0000000..44b2108
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/sim.py	
@@ -0,0 +1,21 @@
+'''
+Created on 7 May 2016
+
+@author: walton
+'''
+from diffcalc.util import allnum
+
+def sim(scn, hkl):
+    """sim hkl scn -- simulates moving scannable (not all)
+    """
+    if not isinstance(hkl, (tuple, list)):
+        raise TypeError
+
+    if not allnum(hkl):
+        raise TypeError()
+
+    try:
+        print scn.simulateMoveTo(hkl)
+    except AttributeError:
+        raise TypeError(
+            "The first argument does not support simulated moves")
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/simulation.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/simulation.py
new file mode 100644
index 0000000..0255a5f
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/simulation.py	
@@ -0,0 +1,139 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import time
+from math import sqrt, pi, exp
+
+try:
+    from gda.device.scannable import PseudoDevice
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import \
+        ScannableBase as PseudoDevice
+
+from diffcalc.ub.crystal import CrystalUnderTest
+from diffcalc.hkl.you.calc import youAnglesToHkl
+from diffcalc.hkl.vlieg.calc import vliegAnglesToHkl
+from diffcalc.hkl.you.geometry import calcCHI, calcPHI
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+class Equation(object):
+
+    def __call__(self, dh, dk, dl):
+        raise Exception('Abstract')
+
+    def __str__(self):
+        "Abstract equation"
+
+
+class Gaussian(Equation):
+
+    def __init__(self, variance):
+        self.variance = float(variance)
+
+    def __call__(self, dh, dk, dl):
+        dr_squared = dh * dh + dk * dk + dl * dl
+        return (1 / sqrt(2 * pi * self.variance) *
+                exp(-dr_squared / (2 * self.variance)))
+
+
+class SimulatedCrystalCounter(PseudoDevice):
+
+    def __init__(self, name, diffractometerScannable, geometryPlugin,
+                 wavelengthScannable, equation=Gaussian(.01), engine='you'):
+        self.setName(name)
+        self.setInputNames([name + '_count'])
+        self.setOutputFormat(['%7.5f'])
+        self.exposureTime = 1
+        self.pause = True
+        self.diffractometerScannable = diffractometerScannable
+        self.geometry = geometryPlugin
+        self.wavelengthScannable = wavelengthScannable
+        self.equation = equation
+        self.engine = engine
+
+        self.cut = None
+        self.UB = None
+        self.chiMissmount = 0.
+        self.phiMissmount = 0.
+        self.setCrystal('cubic', 1, 1, 1, 90, 90, 90)
+
+    def setCrystal(self, name, a, b, c, alpha, beta, gamma):
+        self.cut = CrystalUnderTest(name, a, b, c, alpha, beta, gamma)
+        self.calcUB()
+
+    def setChiMissmount(self, chi):
+        self.chiMissmount = chi
+        self.calcUB()
+
+    def setPhiMissmount(self, phi):
+        self.phiMissmount = phi
+        self.calcUB()
+
+    def calcUB(self):
+        CHI = calcCHI(self.chiMissmount * TORAD)
+        PHI = calcPHI(self.phiMissmount * TORAD)
+        self.UB = CHI * PHI * self.cut.B
+
+    def asynchronousMoveTo(self, exposureTime):
+        self.exposureTime = exposureTime
+        if self.pause:
+            time.sleep(exposureTime)  # Should not technically block!
+
+    def getPosition(self):
+        h, k, l = self.getHkl()
+        dh, dk, dl = h - round(h), k - round(k), l - round(l)
+        count = self.equation(dh, dk, dl)
+        #return self.exposureTime, count*self.exposureTime
+        return count * self.exposureTime
+
+    def getHkl(self):
+        pos = self.geometry.physical_angles_to_internal_position(
+            self.diffractometerScannable.getPosition())
+        pos.changeToRadians()
+        wavelength = self.wavelengthScannable.getPosition()
+        if self.engine.lower() == 'vlieg':
+            return vliegAnglesToHkl(pos, wavelength, self.UB)
+        elif self.engine.lower() == 'you':
+            return youAnglesToHkl(pos, wavelength, self.UB)
+        else:
+            raise ValueError(self.engine)
+
+    def isBusy(self):
+        return False
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        s = 'simulated crystal detector: %s\n' % self.getName()
+        h, k, l = self.getHkl()
+        s += '   h : %f\n' % h
+        s += '   k : %f\n' % k
+        s += '   l : %f\n' % l
+        s += self.cut.__str__() + '\n'
+        s += "chi orientation: %s\n" % self.chiMissmount
+        s += "phi orientation: %s\n" % self.phiMissmount
+        ub = self.UB.tolist()
+        s += "UB:\n"
+        s += "     % 18.13f% 18.13f% 18.12f\n" % (ub[0][0], ub[0][1], ub[0][2])
+        s += "     % 18.13f% 18.13f% 18.12f\n" % (ub[1][0], ub[1][1], ub[1][2])
+        s += "     % 18.13f% 18.13f% 18.12f\n" % (ub[2][0], ub[2][1], ub[2][2])
+        return s
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/slave_driver.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/slave_driver.py
new file mode 100644
index 0000000..cd5ce24
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/slave_driver.py	
@@ -0,0 +1,109 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import  pi, tan, sin, atan, cos, atan2
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+class SlaveScannableDriver(object):
+
+    def __init__(self, scannables):
+        self.scannables = scannables
+
+    def isBusy(self):
+        for scn in self.scannables:
+            if scn.isBusy():
+                return True
+        return False
+
+    def waitWhileBusy(self):
+        for scn in self.scannables:
+            scn.waitWhileBusy()
+
+    def triggerAsynchronousMove(self, triggerPos):
+        nu = self.slaveFromTriggerPos(triggerPos)
+        for scn in self.scannables:
+            scn.asynchronousMoveTo(nu)
+
+    def getPosition(self):
+        return self.scannables[0].getPosition()
+
+    def slaveFromTriggerPos(self, triggerPos):
+        raise Exception("Abstract")
+
+    def getScannableNames(self):
+        return [scn.name for scn in self.scannables]
+
+    def getOutputFormat(self):
+        return [list(scn.outputFormat)[0] for scn in self.scannables]
+
+    def getPositions(self):
+        return [float(scn.getPosition()) for scn in self.scannables]
+
+
+"""
+Based on: Elias Vlieg, "A (2+3)-Type Surface Diffractometer: Mergence of the
+z-axis and (2+2)-Type Geometries", J. Appl. Cryst. (1998). 31. 198-203
+"""
+
+
+class NuDriverForSixCirclePlugin(SlaveScannableDriver):
+
+    def slaveFromTriggerPos(self, triggerPos):
+
+        alpha, delta, gamma, _, _, _ = triggerPos
+        alpha = alpha * TORAD
+        delta = delta * TORAD
+        gamma = gamma * TORAD
+
+        ### Equation16 RHS ###
+        rhs = -1 * tan(gamma - alpha) * sin(delta)
+        nu = atan(rhs)  # -pi/2 <= nu <= pi/2
+        return nu * TODEG
+
+
+class NuDriverForWillmottHorizontalGeometry(SlaveScannableDriver):
+
+    """
+    Based on: Phillip Willmott, "Angle calculations for a (2+3)-type
+    diffractometer: focus on area detectors", J. Appl. Cryst. (2011). 44.
+    73-83
+    """
+
+    def __init__(self, scannables, area_detector=False):
+        SlaveScannableDriver.__init__(self, scannables)
+        self.area_detector = area_detector
+
+    def slaveFromTriggerPos(self, triggerPos):
+
+        delta, gamma, omegah, _ = triggerPos
+        delta *= TORAD
+        gamma *= TORAD
+        omegah *= TORAD
+        if self.area_detector:
+            nu = atan2(sin(delta - omegah), tan(gamma))                  # (66)
+        else:
+            top = -sin(gamma) * sin(omegah)
+            bot = (sin(omegah) * cos(gamma) * sin(delta) +
+                   cos(omegah) * cos(delta))
+            nu = atan2(top, bot)                                         # (61)
+
+        print 'nu:', nu * TODEG
+        return nu * TODEG
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/vrmlanimator.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/vrmlanimator.py
new file mode 100644
index 0000000..9f40441
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/vrmlanimator.py	
@@ -0,0 +1,184 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import time
+import threading
+import socket
+PORT = 4567
+
+from gda.device.scannable import ScannableMotionWithScannableFieldsBaseTest
+
+#import scannable.vrmlModelDriver
+#reload(scannable.vrmlModelDriver);from scannable.vrmlModelDriver import \
+#     VrmlModelDriver, LinearProfile, MoveThread
+#fc=VrmlModelDriver(
+#    'fc',['alpha','delta','omega', 'chi','phi'], speed=30, host='diamrl5104')
+#alpha = fc.alpha
+#delta = fc.delta
+#omega = fc.omega
+#chi = fc.chi
+#phi = fc.phi
+
+
+def connect_to_socket(host, port):
+    print "Connecting to %s on port %d" % (host, port)
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.connect((host, port))
+    print "Connected"
+    socketfile = sock.makefile('rw', 0)
+    return socketfile
+
+
+class LinearProfile(object):
+
+    def __init__(self, v, t_accel, startList, endList):
+        assert len(startList) == len(endList)
+        self.v = float(v)
+        self.start = startList
+        self.end = endList
+        self.t_accel = t_accel
+
+        distances = [e - s for e, s in zip(self.end, self.start)]
+        max_distance = max([abs(d) for d in distances])
+        if max_distance == 0:
+            self.delta_time = 0
+        else:
+            self.delta_time = abs(max_distance / self.v)
+            self.speeds = [d / self.delta_time for d in distances]
+        self.start_time = time.time()
+
+    def getPosition(self):
+        if self.start_time is None:
+            return self.start
+        if not self.isMoving():
+            return self.end
+        t = abs(float(time.time() - self.start_time))
+        if t > self.delta_time:
+            # we are in the deceleration phase (i.e paused for now)
+            return self.end
+        return [s + v * t for s, v in zip(self.start, self.speeds)]
+
+    def isMoving(self):
+        return time.time() < self.start_time + self.delta_time + self.t_accel
+
+
+class MoveThread(threading.Thread):
+
+    def __init__(self, profile, socketfile, axisNames):
+        threading.Thread.__init__(self)
+        self.profile = profile
+        self.socketfile = socketfile
+        self.axisNames = axisNames
+
+    def run(self):
+        while self.profile.isMoving():
+            self.update()
+            time.sleep(.1)
+        self.update()
+
+    def update(self):
+        pos = self.profile.getPosition()
+        d = dict(zip(map(str, self.axisNames), pos))
+        if self.socketfile:
+            self.socketfile.write(repr(d) + '\n')
+
+
+class VrmlModelDriver(ScannableMotionWithScannableFieldsBaseTest):
+
+    def __init__(self, name, axes_names, host=None, speed=60, t_accel=.1,
+                 format='%.3f'):
+        self.name = name
+        self.inputNames = list(axes_names)
+        self.extraNames = []
+        self.outputFormat = [format] * len(self.inputNames)
+        self.completeInstantiation()
+        self.__last_target = [0.] * len(self.inputNames)
+        self.verbose = False
+        self.move_thread = None
+        self.speed = speed
+        self.host = host
+        self.t_accel = t_accel
+        self.socketfile = None
+        if self.host:
+            try:
+                self.connect()
+            except socket.error:
+                print "Failed to connect to %s:%r" % (self.host, PORT)
+                print "Connect with: %s.connect()" % self.name
+
+    def connect(self):
+        self.socketfile = connect_to_socket(self.host, PORT)
+        self.rawAsynchronousMoveTo(self.__last_target)
+
+    def isBusy(self):
+        if self.move_thread is None:
+            return False
+        return self.move_thread.profile.isMoving()
+
+    def rawGetPosition(self):
+        if self.move_thread is None:
+            return self.__last_target
+        else:
+            return self.move_thread.profile.getPosition()
+
+    def rawAsynchronousMoveTo(self, targetList):
+        if self.isBusy():
+            raise Exception(self.name + ' is already moving')
+        if self.verbose:
+            print self.name + ".rawAsynchronousMoveTo(%r)" % targetList
+
+        for i, target in enumerate(targetList):
+            if target is None:
+                targetList[i] = self.__last_target[i]
+        profile = LinearProfile(
+            self.speed, self.t_accel, self.__last_target, targetList)
+        self.move_thread = MoveThread(
+            profile, self.socketfile, self.inputNames)
+        self.move_thread.start()
+        self.__last_target = targetList
+
+    def getFieldPosition(self, index):
+        return self.getPosition()[index]
+
+    def __del__(self):
+        self.socketfile.close()
+
+#class TrapezoidProfile(object):
+#
+#    def __init__(self, t_accel, v_max, delta_x):
+#        self.t_a = t_accel
+#        self.v_m = v_max
+#        self.delta_x = delta_x
+#
+#        self.t_c = (self.X - self.v_m*self.t_a) / self.v_m
+#
+#    def x(self, t):
+#        if self.t_c <=0:
+#            return self.__xshort(t)
+#        else:
+#            return self.__xlong(t)
+#
+#    def __xshort(self, t):
+#        delta_t = 2 * sqrt(self.delta_x*self.t_a/self.v_m)
+#        if t <= .5*delta_t:
+#            return (.5*self.v_m/self.t_a) * t**2
+#        else:
+#            v_peak = (self.v_m/self.t_a) * .5*delta_t
+#            return (t-.5*delta_t)*v_peak - (t-.5*delta_t)**2 ####HERE, bugged
+#            self.delta_x/2
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/wavelength.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/wavelength.py
new file mode 100644
index 0000000..52fd925
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/scannable/wavelength.py	
@@ -0,0 +1,50 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+try:
+    from gdascripts.pd.dummy_pds import DummyPD
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+
+class Wavelength(DummyPD):
+
+    def __init__(self, name, energyScannable,
+                 energyScannableMultiplierToGetKeV=1):
+        self.energyScannable = energyScannable
+        self.energyScannableMultiplierToGetKeV = \
+            energyScannableMultiplierToGetKeV
+
+        DummyPD.__init__(self, name)
+
+    def asynchronousMoveTo(self, pos):
+        self.energyScannable.asynchronousMoveTo(
+            (12.39842 / pos) / self.energyScannableMultiplierToGetKeV)
+
+    def getPosition(self):
+        energy = self.energyScannable.getPosition()
+        if energy == 0:
+            raise Exception(
+                      "The energy is 0, so no wavelength could be calculated.run_All()")
+        return 12.39842 / (energy * self.energyScannableMultiplierToGetKeV)
+
+    def isBusy(self):
+        return self.energyScannable.isBusy()
+
+    def waitWhileBusy(self):
+        return self.energyScannable.waitWhileBusy()
diff --git a/script/test/diffcalc (copy)/diffcalc/gdasupport/you.py b/script/test/diffcalc (copy)/diffcalc/gdasupport/you.py
new file mode 100644
index 0000000..609a344
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/gdasupport/you.py	
@@ -0,0 +1,113 @@
+from diffcalc.gdasupport.scannable.diffractometer import DiffractometerScannableGroup
+from diffcalc.gdasupport.scannable.hkl import Hkl
+from diffcalc.gdasupport.scannable.simulation import SimulatedCrystalCounter
+from diffcalc.gdasupport.scannable.wavelength import Wavelength
+from diffcalc.gdasupport.scannable.parameter import DiffractionCalculatorParameter
+
+
+from diffcalc.dc import dcyou as _dc
+from diffcalc.dc.help import format_command_help
+reload(_dc)
+from diffcalc.dc.dcyou import *  # @UnusedWildImport
+from diffcalc import settings
+
+try:
+    import gda  # @UnusedImport @UnresolvedImport
+    GDA = True
+except:
+    GDA = False
+    
+if not GDA:
+    from diffcalc.gdasupport.minigda import command
+    _pos = command.Pos()
+    _scan = command.Scan(command.ScanDataPrinter())
+
+    def pos(*args):
+        """
+        pos                   show position of all Scannables
+        pos scn               show position of scn
+        pos scn targetmove    scn to target (a number)
+        """
+        return _pos(*args)
+
+    def scan(*args):
+        """
+        scan scn start stop step {scn {target}} {det t}
+        """
+        return _scan(*args)
+
+
+from diffcalc.gdasupport.scannable.sim import sim  # @UnusedImport
+
+_scn_group = settings.axes_scannable_group
+_diff_scn_name = settings.geometry.name # @UndefinedVariable
+_energy_scannable = settings.energy_scannable
+
+
+# Create diffractometer scannable
+_diff_scn = DiffractometerScannableGroup(_diff_scn_name, _dc, _scn_group)
+globals()[_diff_scn_name] = _diff_scn
+
+# Create hkl scannables
+hkl = Hkl('hkl', _scn_group, _dc)
+h = hkl.h
+k = hkl.k
+l = hkl.l
+
+Hkl.dynamic_docstring = format_command_help(hkl_commands_for_help)  # must be on the class
+ub.__doc__ = format_command_help(ub_commands_for_help)
+
+_virtual_angles = ('theta', 'qaz', 'alpha', 'naz', 'tau', 'psi', 'beta')
+hklverbose = Hkl('hklverbose', _scn_group, _dc, _virtual_angles)
+
+
+# Create wavelength scannable
+wl = Wavelength(
+    'wl', _energy_scannable, settings.energy_scannable_multiplier_to_get_KeV)
+if not GDA:
+    wl.asynchronousMoveTo(1)  # Angstrom
+_energy_scannable.level = 3
+wl.level = 3
+
+
+# Create simulated counter timer
+ct = SimulatedCrystalCounter('ct', _scn_group, settings.geometry, wl)
+ct.level = 10
+
+
+# Create constraint scannables
+def _create_constraint_scannable(con_name, scn_name=None):
+    if not scn_name:
+        scn_name = con_name
+    return DiffractionCalculatorParameter(
+        scn_name, con_name, _dc.constraint_manager)
+     
+# Detector constraints
+def isconstrainable(name):
+    return not constraint_manager.is_constraint_fixed(name)
+
+if isconstrainable('delta'): delta_con = _create_constraint_scannable('delta', 'delta_con')
+if isconstrainable('gam'): gam_con = _create_constraint_scannable('gam', 'gam_con')
+if isconstrainable('qaz'): qaz = _create_constraint_scannable('qaz')
+if isconstrainable('naz'): naz = _create_constraint_scannable('naz')
+
+# Reference constraints
+alpha = _create_constraint_scannable('alpha')
+beta = _create_constraint_scannable('beta')
+psi = _create_constraint_scannable('psi')
+a_eq_b = 'a_eq_b'
+
+# Sample constraints
+if isconstrainable('mu'): mu_con = _create_constraint_scannable('mu', 'mu_con')
+if isconstrainable('eta'): eta_con = _create_constraint_scannable('eta', 'eta_con')
+if isconstrainable('chi'): chi_con = _create_constraint_scannable('chi', 'chi_con')
+if isconstrainable('phi'): phi_con = _create_constraint_scannable('phi', 'phi_con')
+if isconstrainable('mu') and isconstrainable('gam'): mu_is_gam = 'mu_is_gam'
+
+
+# Cleanup to allow "from gdasupport.you import *"
+del DiffractometerScannableGroup, Hkl, SimulatedCrystalCounter
+del Wavelength, DiffractionCalculatorParameter
+
+# Cleanup other cruft
+del format_command_help
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/hardware.py b/script/test/diffcalc (copy)/diffcalc/hardware.py
new file mode 100644
index 0000000..274feaf
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hardware.py	
@@ -0,0 +1,382 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from __future__ import absolute_import
+
+from diffcalc.util import DiffcalcException
+from diffcalc import settings
+
+SMALL = 1e-8
+
+from diffcalc.util import command
+
+__all__ = ['hardware', 'setcut', 'setmin', 'setmax']
+
+
+def getNameFromScannableOrString(o):
+        try:  # it may be a scannable
+            return o.getName()
+        except AttributeError:
+            return str(o)
+
+
+
+@command
+def hardware():
+    """hardware  -- show diffcalc limits and cuts"""
+    print settings.hardware.repr_sector_limits_and_cuts()  # @UndefinedVariable
+
+@command
+def setcut(scannable_or_string=None, val=None):
+    """setcut {name {val}} -- sets cut angle
+    """
+    if scannable_or_string is None and val is None:
+        print settings.hardware.repr_sector_limits_and_cuts()  # @UndefinedVariable
+    else:
+        name = getNameFromScannableOrString(scannable_or_string)
+        if val is None:
+            print '%s: %f' % (name, settings.hardware.get_cuts()[name])  # @UndefinedVariable
+        else:
+            oldcut = settings.hardware.get_cuts()[name]  # @UndefinedVariable
+            settings.hardware.set_cut(name, float(val))  # @UndefinedVariable
+            newcut = settings.hardware.get_cuts()[name]  # @UndefinedVariable
+
+@command
+def setmin(name=None, val=None):
+    """setmin {axis {val}} -- set lower limits used by auto sector code (None to clear)""" #@IgnorePep8
+    _setMinOrMax(name, val, settings.hardware.set_lower_limit)  # @UndefinedVariable
+
+@command
+def setmax(name=None, val=None):
+    """setmax {name {val}} -- sets upper limits used by auto sector code (None to clear)""" #@IgnorePep8
+    _setMinOrMax(name, val, settings.hardware.set_upper_limit)  # @UndefinedVariable
+
+@command
+def setrange(name=None, lower=None, upper=None):
+    """setrange {axis {min} {max}} -- set lower and upper limits used by auto sector code (None to clear)""" #@IgnorePep8
+    _setMinOrMax(name, lower, settings.hardware.set_lower_limit)  # @UndefinedVariable
+    _setMinOrMax(name, upper, settings.hardware.set_upper_limit)  # @UndefinedVariable
+
+def _setMinOrMax(name, val, setMethod):
+    if name is None:
+        print settings.hardware.repr_sector_limits_and_cuts()  # @UndefinedVariable
+    else:
+        name = getNameFromScannableOrString(name)
+        if val is None:
+            print settings.hardware.repr_sector_limits_and_cuts(name)  # @UndefinedVariable
+        else:
+            setMethod(name, float(val))
+
+
+commands_for_help = ['Hardware',
+                     hardware,
+                     setcut,
+                     setmin,
+                     setmax]
+
+
+class HardwareAdapter(object):
+
+    def __init__(self, diffractometerAngleNames, defaultCuts={},
+                 energyScannableMultiplierToGetKeV=1):
+
+        self._diffractometerAngleNames = diffractometerAngleNames
+        self._upperLimitDict = {}
+        self._lowerLimitDict = {}
+        self._cut_angles = {}
+        self._configure_cuts(defaultCuts)
+        self.energyScannableMultiplierToGetKeV = \
+            energyScannableMultiplierToGetKeV
+        self._name = 'base'
+
+    @property
+    def name(self):
+        return self._name
+
+    def get_axes_names(self):
+        return tuple(self._diffractometerAngleNames)
+
+    def get_position(self):
+        """pos = get_position() -- returns the current physical diffractometer
+        position as a diffcalc.util object in degrees
+        """
+        raise NotImplementedError()
+
+    def get_wavelength(self):
+        """wavelength = get_wavelength() -- returns wavelength in Angstroms
+        """
+        return 12.39842 / self.get_energy()
+
+    def get_energy(self):
+        """energy = get_energy() -- returns energy in kEv  """
+        raise NotImplementedError()
+
+    def __str__(self):
+        s = self.name + ":\n"
+        s += "  energy : " + str(self.get_energy()) + " keV\n"
+        s += "  wavelength : " + str(self.get_wavelength()) + " Angstrom\n"
+        names = self._diffractometerAngleNames
+        for name, pos in zip(names, self.get_position()):
+            s += "  %s : %r deg\n" % (name, pos)
+        return s
+
+    def __repr__(self):
+        return self.__str__()
+
+    def get_position_by_name(self, angleName):
+        names = list(self._diffractometerAngleNames)
+        return self.get_position()[names.index(angleName)]
+
+### Limits ###
+
+    def get_lower_limit(self, name):
+        '''returns lower limits by axis name. Limit may be None if not set
+        '''
+        if name not in self._diffractometerAngleNames:
+            raise ValueError("No angle called %s. Try one of: %s" %
+                             (name, self._diffractometerAngleNames))
+        return self._lowerLimitDict.get(name)
+
+    def get_upper_limit(self, name):
+        '''returns upper limit by axis name. Limit may be None if not set
+        '''
+        if name not in self._diffractometerAngleNames:
+            raise ValueError("No angle called %s. Try one of: %s" %
+                             name, self._diffractometerAngleNames)
+        return self._upperLimitDict.get(name)
+
+    def set_lower_limit(self, name, value):
+        """value may be None to remove limit"""
+        if name not in self._diffractometerAngleNames:
+            raise ValueError(
+                "Cannot set lower Diffcalc limit: No angle called %s. Try one "
+                "of: %s" % (name, self._diffractometerAngleNames))
+        if value is None:
+            try:
+                del self._lowerLimitDict[name]
+            except KeyError:
+                print ("WARNING: There was no lower Diffcalc limit %s set to "
+                       "clear" % name)
+        else:
+            self._lowerLimitDict[name] = value
+
+    def set_upper_limit(self, name, value):
+        """value may be None to remove limit"""
+        if name not in self._diffractometerAngleNames:
+            raise ValueError(
+                "Cannot set upper Diffcalc limit: No angle called %s. Try one "
+                "of: %s" % (name, self._diffractometerAngleNames))
+        if value is None:
+            try:
+                del self._upperLimitDict[name]
+            except KeyError:
+                print ("WARNING: There was no upper Diffcalc limit %s set to "
+                       "clear" % name)
+        else:
+            self._upperLimitDict[name] = value
+
+    def is_position_within_limits(self, positionArray):
+        """
+        where position array is in degrees and cut to be between -180 and 180
+        """
+        names = self._diffractometerAngleNames
+        for axis_name, value in zip(names, positionArray):
+            if not self.is_axis_value_within_limits(axis_name, value):
+                return False
+        return True
+
+    def is_axis_value_within_limits(self, axis_name, value):
+        if axis_name in self._upperLimitDict:
+            if value > self._upperLimitDict[axis_name]:
+                return False
+        if axis_name in self._lowerLimitDict:
+            if value < self._lowerLimitDict[axis_name]:
+                return False
+        return True
+
+    def repr_sector_limits_and_cuts(self, name=None):
+        if name is None:
+            s = ''
+            for name in self.get_axes_names():
+                s += self.repr_sector_limits_and_cuts(name) + '\n'
+            s += "Note: When auto sector/transforms are used,\n "
+            s += "      cuts are applied before checking limits."
+            return s
+        # limits:
+        low = self.get_lower_limit(name)
+        high = self.get_upper_limit(name)
+        s = '  '
+        if low is not None:
+            s += "% 6.1f <= " % low
+        else:
+            s += ' ' * 10
+        s += '%5s' % name
+        if high is not None:
+            s += " <= % 6.1f" % high
+        else:
+            s += ' ' * 10
+        # cuts:
+        try:
+            if self.get_cuts()[name] is not None:
+                s += " (cut: % 6.1f)" % self.get_cuts()[name]
+        except KeyError:
+            pass
+
+        return s
+
+### Cutting Stuff ###
+
+    def _configure_cuts(self, defaultCutsDict):
+        # 1. Set default cut angles
+        self._cut_angles = dict.fromkeys(self._diffractometerAngleNames, -180.)
+        if 'phi' in self._cut_angles:
+            self._cut_angles['phi'] = 0.
+        # 2. Overide with user-specified cuts
+        for name, val in defaultCutsDict.iteritems():
+            self.set_cut(name, val)
+
+    def set_cut(self, name, value):
+        if name in self._cut_angles:
+            self._cut_angles[name] = value
+        else:
+            raise KeyError("Diffractometer has no angle %s. Try: %s." %
+                            (name, self._diffractometerAngleNames))
+
+    def get_cuts(self):
+        return self._cut_angles
+
+    def cut_angles(self, positionArray):
+        '''Assumes each angle in positionArray is between -360 and 360
+        '''
+        cutArray = []
+        names = self._diffractometerAngleNames
+        for axis_name, value in zip(names, positionArray):
+            cutArray.append(self.cut_angle(axis_name, value))
+        return tuple(cutArray)
+
+    def cut_angle(self, axis_name, value):
+        cut_angle = self._cut_angles[axis_name]
+        if cut_angle is None:
+            return value
+        return cut_angle_at(cut_angle, value)
+
+
+def cut_angle_at(cut_angle, value):
+    if (cut_angle == 0 and (abs(value - 360) < SMALL) or
+        (abs(value + 360) < SMALL) or
+        (abs(value) < SMALL)):
+        value = 0.
+    if value < (cut_angle - SMALL):
+        return value + 360.
+    elif value >= cut_angle + 360. + SMALL:
+        return value - 360.
+    else:
+        return value
+
+
+class DummyHardwareAdapter(HardwareAdapter):
+
+    def __init__(self, diffractometerAngleNames):
+        super(self.__class__, self).__init__(diffractometerAngleNames)
+#         HardwareAdapter.__init__(self, diffractometerAngleNames)
+
+        self._position = [0.] * len(diffractometerAngleNames)
+        self._wavelength = 1.
+        self.energyScannableMultiplierToGetKeV = 1
+        self._name = "Dummy"
+
+# Required methods
+
+    def get_position(self):
+        """
+        pos = getDiffractometerPosition() -- returns the current physical
+        diffractometer position as a list in degrees
+        """
+        return self._position
+
+    def _set_position(self, pos):
+        assert len(pos) == len(self.get_axes_names()), \
+            "Wrong length of input list"
+        self._position = pos
+
+    position = property(get_position, _set_position)
+
+    def get_energy(self):
+        """energy = get_energy() -- returns energy in kEv  """
+        if self._wavelength is None:
+            raise DiffcalcException(
+                "Energy or wavelength have not been set")
+        return (12.39842 /
+                (self._wavelength * self.energyScannableMultiplierToGetKeV))
+
+    def _set_energy(self, energy):
+        self._wavelength = 12.39842 / energy
+
+    energy = property(get_energy, _set_energy)
+
+    def get_wavelength(self):
+        """wavelength = get_wavelength() -- returns wavelength in Angstroms"""
+        if self._wavelength is None:
+            raise DiffcalcException(
+                "Energy or wavelength have not been set")
+        return self._wavelength
+
+    def _set_wavelength(self, wavelength):
+        self._wavelength = wavelength
+
+    wavelength = property(get_wavelength, _set_wavelength)
+
+
+class ScannableHardwareAdapter(HardwareAdapter):
+
+    def __init__(self, diffractometerScannable, energyScannable,
+                 energyScannableMultiplierToGetKeV=1):
+        input_names = diffractometerScannable.getInputNames()
+        super(self.__class__, self).__init__(input_names)
+#         HardwareAdapter.__init__(self, input_names)
+        self.diffhw = diffractometerScannable
+        self.energyhw = energyScannable
+        self.energyScannableMultiplierToGetKeV = \
+            energyScannableMultiplierToGetKeV
+        self._name = "ScannableHarwdareMonitor"
+
+# Required methods
+
+    def get_position(self):
+        """
+        pos = getDiffractometerPosition() -- returns the current physical
+        diffractometer position as a list in degrees
+        """
+        return self.diffhw.getPosition()
+
+    def get_energy(self):
+        """energy = get_energy() -- returns energy in kEv (NOT eV!) """
+        multiplier = self.energyScannableMultiplierToGetKeV
+        energy = self.energyhw.getPosition() * multiplier
+        if energy is None:
+            raise DiffcalcException("Energy has not been set")
+        return energy
+
+    def get_wavelength(self):
+        """wavelength = get_wavelength() -- returns wavelength in Angstroms"""
+        energy = self.get_energy()
+        return 12.39842 / energy
+
+    @property
+    def name(self):
+        return self.diffhw.getName()
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/__init__.py b/script/test/diffcalc (copy)/diffcalc/hkl/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/calcbase.py b/script/test/diffcalc (copy)/diffcalc/hkl/calcbase.py
new file mode 100644
index 0000000..c4db5f3
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/calcbase.py	
@@ -0,0 +1,155 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi
+
+from diffcalc.util import DiffcalcException, differ
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+class HklCalculatorBase(object):
+
+    def __init__(self, ubcalc, geometry, hardware,
+                 raiseExceptionsIfAnglesDoNotMapBackToHkl=False):
+
+        self._ubcalc = ubcalc  # to get the UBMatrix, tau and sigma
+        self._geometry = geometry   # to access information about the
+                                    # diffractometer geometry and mode_selector
+        self._hardware = hardware  # Used for tracking parameters only
+        self.raiseExceptionsIfAnglesDoNotMapBackToHkl = \
+            raiseExceptionsIfAnglesDoNotMapBackToHkl
+
+    def anglesToHkl(self, pos, wavelength):
+        """
+        Return hkl tuple and dictionary of all virtual angles in degrees from
+        Position in degrees and wavelength in Angstroms.
+        """
+
+        h, k, l = self._anglesToHkl(pos.inRadians(), wavelength)
+        paramDict = self.anglesToVirtualAngles(pos, wavelength)
+        return ((h, k, l), paramDict)
+
+    def anglesToVirtualAngles(self, pos, wavelength):
+        """
+        Return dictionary of all virtual angles in degrees from Position object
+        in degrees and wavelength in Angstroms.
+        """
+        anglesDict = self._anglesToVirtualAngles(pos.inRadians(), wavelength)
+        for name in anglesDict:
+            anglesDict[name] = anglesDict[name] * TODEG
+        return anglesDict
+
+    def hklToAngles(self, h, k, l, wavelength):
+        """
+        Return verified Position and all virtual angles in degrees from
+        h, k & l and wavelength in Angstroms.
+
+        The calculated Position is verified by checking that it maps back using
+        anglesToHkl() to the requested hkl value.
+
+        Those virtual angles fixed or generated while calculating the position
+        are verified by by checking that they map back using
+        anglesToVirtualAngles to the virtual angles for the given position.
+
+        Throws a DiffcalcException if either check fails and
+        raiseExceptionsIfAnglesDoNotMapBackToHkl is True, otherwise displays a
+        warning.
+        """
+
+        # Update tracked parameters. During this calculation parameter values
+        # will be read directly from self._parameters instead of via
+        # self.getParameter which would trigger another potentially time-costly
+        # position update.
+        self.parameter_manager.update_tracked()
+
+        pos, virtualAngles = self._hklToAngles(h, k, l, wavelength)  # in rad
+
+        # to degrees:
+        pos.changeToDegrees()
+        
+        for key, val in virtualAngles.items():
+            if val is not None:
+                virtualAngles[key] = val * TODEG
+
+        self._verify_pos_map_to_hkl(h, k, l, wavelength, pos)
+
+        virtualAnglesReadback = self._verify_virtual_angles(h, k, l, wavelength, pos, virtualAngles)
+
+        return pos, virtualAnglesReadback
+
+    def _verify_pos_map_to_hkl(self, h, k, l, wavelength, pos):
+        hkl, _ = self.anglesToHkl(pos, wavelength)
+        e = 0.001
+        if ((abs(hkl[0] - h) > e) or (abs(hkl[1] - k) > e) or 
+            (abs(hkl[2] - l) > e)):
+            s = "ERROR: The angles calculated for hkl=(%f,%f,%f) were %s.\n" % (h, k, l, str(pos))
+            s += "Converting these angles back to hkl resulted in hkl="\
+            "(%f,%f,%f)" % (hkl[0], hkl[1], hkl[2])
+            if self.raiseExceptionsIfAnglesDoNotMapBackToHkl:
+                raise DiffcalcException(s)
+            else:
+                print s
+
+    def _verify_virtual_angles(self, h, k, l, wavelength, pos, virtualAngles):
+        # Check that the virtual angles calculated/fixed during the hklToAngles
+    # those read back from pos using anglesToVirtualAngles
+        virtualAnglesReadback = self.anglesToVirtualAngles(pos, wavelength)
+        for key, val in virtualAngles.items():
+            if val != None: # Some values calculated in some mode_selector
+                r = virtualAnglesReadback[key]
+                if ((differ(val, r, .00001) and differ(val, r + 360, .00001) and differ(val, r - 360, .00001))):
+                    s = "ERROR: The angles calculated for hkl=(%f,%f,%f) with"\
+                    " mode=%s were %s.\n" % (h, k, l, self.repr_mode(), str(pos))
+                    s += "During verification the virtual angle %s resulting "\
+                    "from (or set for) this calculation of %f" % (key, val)
+                    s += "did not match that calculated by "\
+                    "anglesToVirtualAngles of %f" % virtualAnglesReadback[key]
+                    if self.raiseExceptionsIfAnglesDoNotMapBackToHkl:
+                        raise DiffcalcException(s)
+                    else:
+                        print s
+        
+        return virtualAnglesReadback
+
+    def repr_mode(self):
+        pass
+
+### Collect all math access to context here
+
+    def _getUBMatrix(self):
+        return self._ubcalc.UB
+
+    def _getMode(self):
+        return self.mode_selector.getMode()
+
+    def _getSigma(self):
+        return self._ubcalc.sigma
+
+    def _getTau(self):
+        return self._ubcalc.tau
+
+    def _getParameter(self, name):
+        # Does not use context.getParameter as this will trigger a costly
+        # parameter collection
+        pm = self.parameter_manager
+        return pm.getParameterWithoutUpdatingTrackedParemeters(name)
+
+    def _getGammaParameterName(self):
+        return self._gammaParameterName
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/common.py b/script/test/diffcalc (copy)/diffcalc/hkl/common.py
new file mode 100644
index 0000000..0b3c13a
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/common.py	
@@ -0,0 +1,55 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+from diffcalc.util import allnum
+
+def getNameFromScannableOrString(o):
+        try:  # it may be a scannable
+            return o.getName()
+        except AttributeError:
+            return str(o)
+            raise TypeError()
+
+
+class DummyParameterManager(object):
+
+    def getParameterDict(self):
+        return {}
+
+    def _setParameter(self, name, value):
+        raise KeyError(name)
+
+    def _getParameter(self, name):
+        raise KeyError(name)
+
+    def update_tracked(self):
+        pass
+
+
+def sim(self, scn, hkl):
+    """sim hkl scn -- simulates moving scannable (not all)
+    """
+    if not isinstance(hkl, (tuple, list)):
+        raise TypeError
+
+    if not allnum(hkl):
+        raise TypeError()
+
+    try:
+        print scn.simulateMoveTo(hkl)
+    except AttributeError:
+        raise TypeError("The first argument does not support simulated moves")
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/__init__.py b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/calc.py b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/calc.py
new file mode 100644
index 0000000..215e31a
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/calc.py	
@@ -0,0 +1,846 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi, asin, acos, sin, cos, sqrt, atan2, fabs, atan
+
+try:
+    from numpy import matrix
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix
+    from numjy.linalg import norm
+
+from diffcalc.hkl.calcbase import HklCalculatorBase
+from diffcalc.hkl.vlieg.transform import TransformCInRadians
+from diffcalc.util import dot3, cross3, bound, differ
+from diffcalc.hkl.vlieg.geometry import createVliegMatrices, \
+    createVliegsPsiTransformationMatrix, \
+    createVliegsSurfaceTransformationMatrices, calcPHI
+from diffcalc.hkl.vlieg.geometry import VliegPosition
+from diffcalc.hkl.vlieg.constraints import VliegParameterManager
+from diffcalc.hkl.vlieg.constraints import ModeSelector
+from diffcalc.ub.calc import PaperSpecificUbCalcStrategy
+
+
+TORAD = pi / 180
+TODEG = 180 / pi
+transformC = TransformCInRadians()
+
+
+PREFER_POSITIVE_CHI_SOLUTIONS = True
+
+I = matrix('1 0 0; 0 1 0; 0 0 1')
+y = matrix('0; 1; 0')
+
+
+def check(condition, ErrorOrStringOrCallable, *args):
+    """
+    fail = check(condition, ErrorOrString) -- if condition is false raises the
+    Exception passed in, or creates one from a string. If a callable function
+    is passed in this is called with any args specified and the thing returns
+    false.
+    """
+    # TODO: Remove (really nasty) check function
+    if condition == False:
+        if callable(ErrorOrStringOrCallable):
+            ErrorOrStringOrCallable(*args)
+            return False
+        elif isinstance(ErrorOrStringOrCallable, str):
+            raise Exception(ErrorOrStringOrCallable)
+        else:  # assume input is an exception
+            raise ErrorOrStringOrCallable
+    return True
+
+
+def sign(x):
+    if x < 0:
+        return -1
+    else:
+        return 1
+
+
+def vliegAnglesToHkl(pos, wavelength, UBMatrix):
+    """
+    Returns hkl indices from pos object in radians.
+    """
+    wavevector = 2 * pi / wavelength
+
+    # Create transformation matrices
+    [ALPHA, DELTA, GAMMA, OMEGA, CHI, PHI] = createVliegMatrices(
+        pos.alpha, pos.delta, pos.gamma, pos.omega, pos.chi, pos.phi)
+
+    # Create the plane normal vector in the alpha axis coordinate frame
+    qa = ((DELTA * GAMMA) - ALPHA.I) * matrix([[0], [wavevector], [0]])
+
+    # Transform the plane normal vector from the alpha frame to reciprical
+    # lattice frame.
+    hkl = UBMatrix.I * PHI.I * CHI.I * OMEGA.I * qa
+
+    return hkl[0, 0], hkl[1, 0], hkl[2, 0]
+
+
+class VliegUbCalcStrategy(PaperSpecificUbCalcStrategy):
+
+    def calculate_q_phi(self, pos):
+
+        [ALPHA, DELTA, GAMMA, OMEGA, CHI, PHI] = createVliegMatrices(
+           pos.alpha, pos.delta, pos.gamma, pos.omega, pos.chi, pos.phi)
+
+        u1a = (DELTA * GAMMA - ALPHA.I) * y
+        u1p = PHI.I * CHI.I * OMEGA.I * u1a
+        return u1p
+
+
+class VliegHklCalculator(HklCalculatorBase):
+
+    def __init__(self, ubcalc, geometry, hardware,
+                 raiseExceptionsIfAnglesDoNotMapBackToHkl=True):
+        r = raiseExceptionsIfAnglesDoNotMapBackToHkl
+        HklCalculatorBase.__init__(self, ubcalc, geometry, hardware,
+                                   raiseExceptionsIfAnglesDoNotMapBackToHkl=r)
+        self._gammaParameterName = ({'arm': 'gamma', 'base': 'oopgamma'}
+                                    [self._geometry.gamma_location])
+        self.mode_selector = ModeSelector(self._geometry, None,
+                                          self._gammaParameterName)
+        self.parameter_manager = VliegParameterManager(
+            self._geometry, self._hardware, self.mode_selector,
+            self._gammaParameterName)
+        self.mode_selector.setParameterManager(self.parameter_manager)
+
+    def __str__(self):
+        # should list paramemeters and indicate which are used in selected mode
+        result = "Available mode_selector:\n"
+        result += self.mode_selector.reportAvailableModes()
+        result += '\nCurrent mode:\n'
+        result += self.mode_selector.reportCurrentMode()
+        result += '\n\nParameters:\n'
+        result += self.parameter_manager.reportAllParameters()
+        return result
+
+    def _anglesToHkl(self, pos, wavelength):
+        """
+        Return hkl tuple from VliegPosition in radians and wavelength in
+        Angstroms.
+        """
+        return vliegAnglesToHkl(pos, wavelength, self._getUBMatrix())
+
+    def _anglesToVirtualAngles(self, pos, wavelength):
+        """
+        Return dictionary of all virtual angles in radians from VliegPosition
+        object win radians and wavelength in Angstroms. The virtual angles are:
+        Bin, Bout, azimuth and 2theta.
+        """
+
+        # Create transformation matrices
+        [ALPHA, DELTA, GAMMA, OMEGA, CHI, PHI] = createVliegMatrices(
+            pos.alpha, pos.delta, pos.gamma, pos.omega, pos.chi, pos.phi)
+        [SIGMA, TAU] = createVliegsSurfaceTransformationMatrices(
+            self._getSigma() * TORAD, self._getTau() * TORAD)
+
+        S = TAU * SIGMA
+        y_vector = matrix([[0], [1], [0]])
+
+        # Calculate Bin from equation 15:
+        surfacenormal_alpha = OMEGA * CHI * PHI * S * matrix([[0], [0], [1]])
+        incoming_alpha = ALPHA.I * y_vector
+        minusSinBetaIn = dot3(surfacenormal_alpha, incoming_alpha)
+        Bin = asin(bound(-minusSinBetaIn))
+
+        # Calculate Bout from equation 16:
+        #  surfacenormal_alpha has just ben calculated
+        outgoing_alpha = DELTA * GAMMA * y_vector
+        sinBetaOut = dot3(surfacenormal_alpha, outgoing_alpha)
+        Bout = asin(bound(sinBetaOut))
+
+        # Calculate 2theta from equation 25:
+
+        cosTwoTheta = dot3(ALPHA * DELTA * GAMMA * y_vector, y_vector)
+        twotheta = acos(bound(cosTwoTheta))
+        psi = self._anglesToPsi(pos, wavelength)
+
+        return {'Bin': Bin, 'Bout': Bout, 'azimuth': psi, '2theta': twotheta}
+
+    def _hklToAngles(self, h, k, l, wavelength):
+        """
+        Return VliegPosition and virtual angles in radians from h, k & l and
+        wavelength in Angstroms. The virtual angles are those fixed or
+        generated while calculating the position: Bin, Bout and 2theta; and
+        azimuth in four and five circle modes.
+        """
+
+        if self._getMode().group in ("fourc", "fivecFixedGamma",
+                                     "fivecFixedAlpha"):
+            return self._hklToAnglesFourAndFiveCirclesModes(h, k, l,
+                                                            wavelength)
+        elif self._getMode().group == "zaxis":
+            return self._hklToAnglesZaxisModes(h, k, l, wavelength)
+        else:
+            raise RuntimeError(
+                'The current mode (%s) has an unrecognised group: %s.'
+                 % (self._getMode().name, self._getMode().group))
+
+    def _hklToAnglesFourAndFiveCirclesModes(self, h, k, l, wavelength):
+        """
+        Return VliegPosition and virtual angles in radians from h, k & l and
+        wavelength in Angstrom for four and five circle modes. The virtual
+        angles are those fixed or generated while calculating the position:
+        Bin, Bout, 2theta and azimuth.
+        """
+
+        # Results in radians during calculations, returned in degreess
+        pos = VliegPosition(None, None, None, None, None, None)
+
+        # Normalise hkl
+        wavevector = 2 * pi / wavelength
+        hklNorm = matrix([[h], [k], [l]]) / wavevector
+
+        # Compute hkl in phi axis coordinate frame
+        hklPhiNorm = self._getUBMatrix() * hklNorm
+
+        # Determine Bin and Bout
+        if self._getMode().name == '4cPhi':
+            Bin = Bout = None
+        else:
+            Bin, Bout = self._determineBinAndBoutInFourAndFiveCirclesModes(
+                                                                    hklNorm)
+
+        # Determine alpha and gamma
+        if self._getMode().group == 'fourc':
+            pos.alpha, pos.gamma = \
+                self._determineAlphaAndGammaForFourCircleModes(hklPhiNorm)
+        else:
+            pos.alpha, pos.gamma = \
+                self._determineAlphaAndGammaForFiveCircleModes(Bin, hklPhiNorm)
+        if pos.alpha < -pi:
+            pos.alpha += 2 * pi
+        if pos.alpha > pi:
+            pos.alpha -= 2 * pi
+
+        # Determine delta
+        (pos.delta, twotheta) = self._determineDelta(hklPhiNorm, pos.alpha,
+                                                     pos.gamma)
+
+        # Determine omega, chi & phi
+        pos.omega, pos.chi, pos.phi, psi = \
+            self._determineSampleAnglesInFourAndFiveCircleModes(
+                hklPhiNorm, pos.alpha, pos.delta, pos.gamma, Bin)
+        # (psi will be None in fixed phi mode)
+
+        # Ensure that by default omega is between -90 and 90, by possibly
+        # transforming the sample angles
+        if self._getMode().name != '4cPhi':  # not in fixed-phi mode
+            if pos.omega < -pi / 2 or pos.omega > pi / 2:
+                pos = transformC.transform(pos)
+
+        # Gather up the virtual angles calculated along the way...
+        #   -pi<psi<=pi
+        if psi is not None:
+            if psi > pi:
+                psi -= 2 * pi
+            if psi < (-1 * pi):
+                psi += 2 * pi
+
+        v = {'2theta': twotheta, 'Bin': Bin, 'Bout': Bout, 'azimuth': psi}
+        return pos, v
+
+    def _hklToAnglesZaxisModes(self, h, k, l, wavelength):
+        """
+        Return VliegPosition and virtual angles in radians from h, k & l and
+        wavelength in Angstroms for z-axis modes. The virtual angles are those
+        fixed or generated while calculating the position: Bin, Bout, and
+        2theta.
+        """
+        # Section 6:
+
+        # Results in radians during calculations, returned in degreess
+        pos = VliegPosition(None, None, None, None, None, None)
+
+        # Normalise hkl
+        wavevector = 2 * pi / wavelength
+        hkl = matrix([[h], [k], [l]])
+        hklNorm = hkl * (1.0 / wavevector)
+
+        # Compute hkl in phi axis coordinate frame
+        hklPhi = self._getUBMatrix() * hkl
+        hklPhiNorm = self._getUBMatrix() * hklNorm
+
+        # Determine Chi and Phi (Equation 29):
+        pos.phi = -self._getTau() * TORAD
+        pos.chi = -self._getSigma() * TORAD
+
+        # Equation 30:
+        [ALPHA, DELTA, GAMMA, OMEGA, CHI, PHI] = createVliegMatrices(
+                None, None, None, None, pos.chi, pos.phi)
+        del ALPHA, DELTA, GAMMA, OMEGA
+        Hw = CHI * PHI * hklPhi
+
+        # Determine Bin and Bout:
+        (Bin, Bout) = self._determineBinAndBoutInZaxisModes(
+            Hw[2, 0] / wavevector)
+
+        # Determine Alpha and Gamma (Equation 32):
+        pos.alpha = Bin
+        pos.gamma = Bout
+
+        # Determine Delta:
+        (pos.delta, twotheta) = self._determineDelta(hklPhiNorm, pos.alpha,
+                                                     pos.gamma)
+
+        # Determine Omega:
+        delta = pos.delta
+        gamma = pos.gamma
+        d1 = (Hw[1, 0] * sin(delta) * cos(gamma) - Hw[0, 0] *
+              (cos(delta) * cos(gamma) - cos(pos.alpha)))
+        d2 = (Hw[0, 0] * sin(delta) * cos(gamma) + Hw[1, 0] *
+              (cos(delta) * cos(gamma) - cos(pos.alpha)))
+
+        if fabs(d2) < 1e-30:
+            pos.omega = sign(d1) * sign(d2) * pi / 2.0
+        else:
+            pos.omega = atan2(d1, d2)
+
+        # Gather up the virtual angles calculated along the way
+        return pos, {'2theta': twotheta, 'Bin': Bin, 'Bout': Bout}
+
+###
+
+    def _determineBinAndBoutInFourAndFiveCirclesModes(self, hklNorm):
+        """(Bin, Bout) = _determineBinAndBoutInFourAndFiveCirclesModes()"""
+        BinModes = ('4cBin', '5cgBin', '5caBin')
+        BoutModes = ('4cBout', '5cgBout', '5caBout')
+        BeqModes = ('4cBeq', '5cgBeq', '5caBeq')
+        azimuthModes = ('4cAzimuth')
+        fixedBusingAndLeviWmodes = ('4cFixedw')
+
+        # Calculate RHS of equation 20
+        # RHS (1/K)(S^-1*U*B*H)_3 where H/K = hklNorm
+        UB = self._getUBMatrix()
+        [SIGMA, TAU] = createVliegsSurfaceTransformationMatrices(
+            self._getSigma() * TORAD, self._getTau() * TORAD)
+        #S = SIGMA * TAU
+        S = TAU * SIGMA
+        RHS = (S.I * UB * hklNorm)[2, 0]
+
+        if self._getMode().name in BinModes:
+            Bin = self._getParameter('betain')
+            check(Bin != None, "The parameter betain must be set for mode %s" %
+                  self._getMode().name)
+            Bin = Bin * TORAD
+            sinBout = RHS - sin(Bin)
+            check(fabs(sinBout) <= 1, "Could not compute Bout")
+            Bout = asin(sinBout)
+
+        elif self._getMode().name in BoutModes:
+            Bout = self._getParameter('betaout')
+            check(Bout != None, "The parameter Bout must be set for mode %s" %
+                  self._getMode().name)
+            Bout = Bout * TORAD
+            sinBin = RHS - sin(Bout)
+            check(fabs(sinBin) <= 1, "Could not compute Bin")
+            Bin = asin(sinBin)
+
+        elif self._getMode().name in BeqModes:
+            sinBeq = RHS / 2
+            check(fabs(sinBeq) <= 1, "Could not compute Bin=Bout")
+            Bin = Bout = asin(sinBeq)
+
+        elif self._getMode().name in azimuthModes:
+            azimuth = self._getParameter('azimuth')
+            check(azimuth != None, "The parameter azimuth must be set for "
+                  "mode %s" % self._getMode().name)
+            del azimuth
+            # TODO: codeit
+            raise NotImplementedError()
+
+        elif self._getMode().name in fixedBusingAndLeviWmodes:
+            bandlomega = self._getParameter('blw')
+            check(bandlomega != None, "The parameter abandlomega must be set "
+                  "for mode %s" % self._getMode().name)
+            del bandlomega
+            # TODO: codeit
+            raise NotImplementedError()
+        else:
+            raise RuntimeError("AngleCalculator does not know how to handle "
+                               "mode %s" % self._getMode().name)
+
+        return (Bin, Bout)
+
+    def _determineBinAndBoutInZaxisModes(self, Hw3OverK):
+        """(Bin, Bout) = _determineBinAndBoutInZaxisModes(HwOverK)"""
+        BinModes = ('6czBin')
+        BoutModes = ('6czBout')
+        BeqModes = ('6czBeq')
+
+        if self._getMode().name in BinModes:
+            Bin = self._getParameter('betain')
+            check(Bin != None, "The parameter betain must be set for mode %s" %
+                  self._getMode().name)
+            Bin = Bin * TORAD
+            # Equation 32a:
+            Bout = asin(Hw3OverK - sin(Bin))
+
+        elif self._getMode().name in BoutModes:
+            Bout = self._getParameter('betaout')
+            check(Bout != None, "The parameter Bout must be set for mode %s" %
+                  self._getMode().name)
+            Bout = Bout * TORAD
+            # Equation 32b:
+            Bin = asin(Hw3OverK - sin(Bout))
+
+        elif self._getMode().name in BeqModes:
+            # Equation 32c:
+            Bin = Bout = asin(Hw3OverK / 2)
+
+        return (Bin, Bout)
+
+###
+
+    def _determineAlphaAndGammaForFourCircleModes(self, hklPhiNorm):
+
+        if self._getMode().group == 'fourc':
+            alpha = self._getParameter('alpha') * TORAD
+            gamma = self._getParameter(self._getGammaParameterName()) * TORAD
+            check(alpha != None, "alpha parameter must be set in fourc modes")
+            check(gamma != None, "gamma parameter must be set in fourc modes")
+            return alpha, gamma
+        else:
+            raise RuntimeError(
+                "determineAlphaAndGammaForFourCirclesModes() "
+                "is not appropriate for %s modes" % self._getMode().group)
+
+    def _determineAlphaAndGammaForFiveCircleModes(self, Bin, hklPhiNorm):
+
+        ## Solve equation 34 for one possible Y, Yo
+        # Calculate surface normal in phi frame
+        [SIGMA, TAU] = createVliegsSurfaceTransformationMatrices(
+            self._getSigma() * TORAD, self._getTau() * TORAD)
+        S = TAU * SIGMA
+        surfaceNormalPhi = S * matrix([[0], [0], [1]])
+        # Compute beta in vector
+        BetaVector = matrix([[0], [-sin(Bin)], [cos(Bin)]])
+        # Find Yo
+        Yo = self._findMatrixToTransformAIntoB(surfaceNormalPhi, BetaVector)
+
+        ## Calculate Hv from equation 39
+        Z = matrix([[1, 0, 0],
+                    [0, cos(Bin), sin(Bin)],
+                    [0, -sin(Bin), cos(Bin)]])
+        Hv = Z * Yo * hklPhiNorm
+        # Fixed gamma:
+        if self._getMode().group == 'fivecFixedGamma':
+            gamma = self._getParameter(self._getGammaParameterName())
+            check(gamma != None,
+                  "gamma parameter must be set in fivecFixedGamma modes")
+            gamma = gamma * TORAD
+            H2 = (hklPhiNorm[0, 0] ** 2 + hklPhiNorm[1, 0] ** 2 +
+                  hklPhiNorm[2, 0] ** 2)
+            a = -(0.5 * H2 * sin(Bin) - Hv[2, 0])
+            b = -(1.0 - 0.5 * H2) * cos(Bin)
+            c = cos(Bin) * sin(gamma)
+            check((b * b + a * a - c * c) >= 0, 'Could not solve for alpha')
+            alpha = 2 * atan2(-(b + sqrt(b * b + a * a - c * c)), -(a + c))
+
+        # Fixed Alpha:
+        elif self._getMode().group == 'fivecFixedAlpha':
+            alpha = self._getParameter('alpha')
+            check(alpha != None,
+                  "alpha parameter must be set in fivecFixedAlpha modes")
+            alpha = alpha * TORAD
+            H2 = (hklPhiNorm[0, 0] ** 2 + hklPhiNorm[1, 0] ** 2 +
+                  hklPhiNorm[2, 0] ** 2)
+            t0 = ((2 * cos(alpha) * Hv[2, 0] - sin(Bin) * cos(alpha) * H2 +
+                  cos(Bin) * sin(alpha) * H2 - 2 * cos(Bin) * sin(alpha)) /
+                  (cos(Bin) * 2.0))
+            check(abs(t0) <= 1, "Cannot compute gamma: sin(gamma)>1")
+            gamma = asin(t0)
+        else:
+            raise RuntimeError(
+                "determineAlphaAndGammaInFiveCirclesModes() is not "
+                "appropriate for %s modes" % self._getMode().group)
+
+        return (alpha, gamma)
+
+###
+
+    def _determineDelta(self, hklPhiNorm, alpha, gamma):
+        """
+        (delta, twotheta) = _determineDelta(hklPhiNorm, alpha, gamma) --
+        computes delta for all modes. Also returns twotheta for sanity
+        checking. hklPhiNorm is a 3X1 matrix.
+
+        alpha, gamma & delta - in radians.
+        h k & l normalised to wavevector and in phi axis coordinates
+        """
+        h = hklPhiNorm[0, 0]
+        k = hklPhiNorm[1, 0]
+        l = hklPhiNorm[2, 0]
+        # See Vlieg section 5 (with K=1)
+        cosdelta = ((1 + sin(gamma) * sin(alpha) - (h * h + k * k + l * l) / 2)
+                    / (cos(gamma) * cos(alpha)))
+        costwotheta = (cos(alpha) * cos(gamma) * bound(cosdelta) -
+                       sin(alpha) * sin(gamma))
+        return (acos(bound(cosdelta)), acos(bound(costwotheta)))
+
+    def _determineSampleAnglesInFourAndFiveCircleModes(self, hklPhiNorm, alpha,
+                                                       delta, gamma, Bin):
+        """
+        (omega, chi, phi, psi)=determineNonZAxisSampleAngles(hklPhiNorm, alpha,
+        delta, gamma, sigma, tau) where hkl has been normalised by the
+        wavevector and is in the phi Axis coordinate frame. All angles in
+        radians. hklPhiNorm is a 3X1 matrix
+        """
+
+        def equation49through59(psi):
+            # equation 49 R = (D^-1)*PI*D*Ro
+            PSI = createVliegsPsiTransformationMatrix(psi)
+            R = D.I * PSI * D * Ro
+
+            #  eq 57: extract omega from R
+            if abs(R[0, 2]) < 1e-20:
+                omega = -sign(R[1, 2]) * sign(R[0, 2]) * pi / 2
+            else:
+                omega = -atan2(R[1, 2], R[0, 2])
+
+            # eq 58: extract chi from R
+            sinchi = sqrt(pow(R[0, 2], 2) + pow(R[1, 2], 2))
+            sinchi = bound(sinchi)
+            check(abs(sinchi) <= 1, 'could not compute chi')
+            # (there are two roots to this equation, but only the first is also
+            # a solution to R33=cos(chi))
+            chi = asin(sinchi)
+
+            # eq 59: extract phi from R
+            if abs(R[2, 0]) < 1e-20:
+                phi = sign(R[2, 1]) * sign(R[2, 1]) * pi / 2
+            else:
+                phi = atan2(-R[2, 1], -R[2, 0])
+            return omega, chi, phi
+
+        def checkSolution(omega, chi, phi):
+            _, _, _, OMEGA, CHI, PHI = createVliegMatrices(
+                None, None, None, omega, chi, phi)
+            R = OMEGA * CHI * PHI
+            RtimesH_phi = R * H_phi
+            print ("R*H_phi=%s, Q_alpha=%s" %
+                   (R * H_phi.tolist(), Q_alpha.tolist()))
+            return not differ(RtimesH_phi, Q_alpha, .0001)
+
+        # Using Vlieg section 7.2
+
+        # Needed througout:
+        [ALPHA, DELTA, GAMMA, _, _, _] = createVliegMatrices(
+            alpha, delta, gamma, None, None, None)
+
+        ## Find Ro, one possible solution to equation 46: R*H_phi=Q_alpha
+
+        # Normalise hklPhiNorm (As it is currently normalised only to the
+        # wavevector)
+        normh = norm(hklPhiNorm)
+        check(normh >= 1e-10, "reciprical lattice vector too close to zero")
+        H_phi = hklPhiNorm * (1 / normh)
+
+        # Create Q_alpha from equation 47, (it comes normalised)
+        Q_alpha = ((DELTA * GAMMA) - ALPHA.I) * matrix([[0], [1], [0]])
+        Q_alpha = Q_alpha * (1 / norm(Q_alpha))
+
+        if self._getMode().name == '4cPhi':
+            ### Use the fixed value of phi as the final constraint ###
+            phi = self._getParameter('phi') * TORAD
+            PHI = calcPHI(phi)
+            H_chi = PHI * H_phi
+            omega, chi = _findOmegaAndChiToRotateHchiIntoQalpha(H_chi, Q_alpha)
+            return (omega, chi, phi, None)  # psi = None as not calculated
+        else:
+            ### Use Bin as the final constraint ###
+
+            # Find a solution Ro to Ro*H_phi=Q_alpha
+            Ro = self._findMatrixToTransformAIntoB(H_phi, Q_alpha)
+
+            ## equation 50: Find a solution D to D*Q=norm(Q)*[[1],[0],[0]])
+            D = self._findMatrixToTransformAIntoB(
+                Q_alpha, matrix([[1], [0], [0]]))
+
+            ## Find psi and create PSI
+
+            # eq 54: compute u=D*Ro*S*[[0],[0],[1]], the surface normal in
+            # psi frame
+            [SIGMA, TAU] = createVliegsSurfaceTransformationMatrices(
+                self._getSigma() * TORAD, self._getTau() * TORAD)
+            S = TAU * SIGMA
+            [u1], [u2], [u3] = (D * Ro * S * matrix([[0], [0], [1]])).tolist()
+            # TODO: If u points along 100, then any psi is a solution. Choose 0
+            if not differ([u1, u2, u3], [1, 0, 0], 1e-9):
+                psi = 0
+                omega, chi, phi = equation49through59(psi)
+            else:
+                # equation 53: V=A*(D^-1)
+                V = ALPHA * D.I
+                v21 = V[1, 0]
+                v22 = V[1, 1]
+                v23 = V[1, 2]
+                # equation 55
+                a = v22 * u2 + v23 * u3
+                b = v22 * u3 - v23 * u2
+                c = -sin(Bin) - v21 * u1  # TODO: changed sign from paper
+
+                # equation 44
+                # Try first root:
+                def myatan2(y, x):
+                    if abs(x) < 1e-20 and abs(y) < 1e-20:
+                        return pi / 2
+                    else:
+                        return atan2(y, x)
+                psi = 2 * myatan2(-(b - sqrt(b * b + a * a - c * c)), -(a + c))
+                #psi = -acos(c/sqrt(a*a+b*b))+atan2(b,a)# -2*pi
+                omega, chi, phi = equation49through59(psi)
+
+            # if u points along z axis, the psi could have been either 0 or 180
+            if (not differ([u1, u2, u3], [0, 0, 1], 1e-9) and
+                abs(psi - pi) < 1e-10):
+                # Choose 0 to match that read up by  angles-to-virtual-angles
+                psi = 0.
+            # if u points a long
+            return (omega, chi, phi, psi)
+
+    def _anglesToPsi(self, pos, wavelength):
+        """
+        pos assumed in radians. -180<= psi <= 180
+        """
+        # Using Vlieg section 7.2
+
+        # Needed througout:
+        [ALPHA, DELTA, GAMMA, OMEGA, CHI, PHI] = createVliegMatrices(
+                pos.alpha, pos.delta, pos.gamma, pos.omega, pos.chi, pos.phi)
+
+        # Solve equation 49 for psi, the rotation of the a reference solution
+        # about Qalpha or H_phi##
+
+        # Find Ro, the reference solution to equation 46: R*H_phi=Q_alpha
+
+        # Create Q_alpha from equation 47, (it comes normalised)
+        Q_alpha = ((DELTA * GAMMA) - ALPHA.I) * matrix([[0], [1], [0]])
+        Q_alpha = Q_alpha * (1 / norm(Q_alpha))
+
+        # Finh H_phi
+        h, k, l = self._anglesToHkl(pos, wavelength)
+        H_phi = self._getUBMatrix() * matrix([[h], [k], [l]])
+        normh = norm(H_phi)
+        check(normh >= 1e-10, "reciprical lattice vector too close to zero")
+        H_phi = H_phi * (1 / normh)
+
+        # Find a solution Ro to Ro*H_phi=Q_alpha
+        # This the reference solution with zero azimuth (psi)
+        Ro = self._findMatrixToTransformAIntoB(H_phi, Q_alpha)
+
+        # equation 48:
+        R = OMEGA * CHI * PHI
+
+        ## equation 50: Find a solution D to D*Q=norm(Q)*[[1],[0],[0]])
+        D = self._findMatrixToTransformAIntoB(Q_alpha, matrix([[1], [0], [0]]))
+
+        # solve equation 49 for psi
+        # D*R = PSI*D*Ro
+        # D*R*(D*Ro)^-1 = PSI
+        PSI = D * R * ((D * Ro).I)
+
+        # Find psi within PSI as defined in equation 51
+        PSI_23 = PSI[1, 2]
+        PSI_33 = PSI[2, 2]
+        psi = atan2(PSI_23, PSI_33)
+
+        #print "PSI: ", PSI.tolist()
+        return psi
+
+    def _findMatrixToTransformAIntoB(self, a, b):
+        """
+        Finds a particular matrix Mo that transforms the unit vector a into the
+        unit vector b. Thats is it finds Mo Mo*a=b. a and b 3x1 matrixes and Mo
+        is a 3x3 matrix.
+
+        Throws an exception if this is not possible.
+            """
+        # Maths from the appendix of "Angle caluculations
+        # for a 5-circle diffractometer used for surface X-ray diffraction",
+        # E. Vlieg, J.F. van der Veen, J.E. Macdonald and M. Miller, J. of
+        # Applied Cryst. 20 (1987) 330.
+        #                                       - courtesy of Elias Vlieg again
+
+        # equation A2: compute angle xi between vectors a and b
+        cosxi = dot3(a, b)
+        try:
+            cosxi = bound(cosxi)
+        except ValueError:
+            raise Exception("Could not compute cos(xi), vectors a=%f and b=%f "
+                            "must be of unit length" % (norm(a), norm(b)))
+        xi = acos(cosxi)
+
+        # Mo is identity matrix if xi zero (math below would blow up)
+        if abs(xi) < 1e-10:
+            return I
+
+        # equation A3: c=cross(a,b)/sin(xi)
+        c = cross3(a, b) * (1 / sin(xi))
+
+        # equation A4: find D matrix that transforms a into the frame
+        # x = a; y = c x a; z = c. */
+        a1 = a[0, 0]
+        a2 = a[1, 0]
+        a3 = a[2, 0]
+        c1 = c[0, 0]
+        c2 = c[1, 0]
+        c3 = c[2, 0]
+        D = matrix([[a1, a2, a3],
+                    [c2 * a3 - c3 * a2, c3 * a1 - c1 * a3, c1 * a2 - c2 * a1],
+                    [c1, c2, c3]])
+
+        # equation A5: create Xi to rotate by xi about z-axis
+        XI = matrix([[cos(xi), -sin(xi), 0],
+                     [sin(xi), cos(xi), 0],
+                     [0, 0, 1]])
+
+        # eq A6: compute Mo
+        return D.I * XI * D
+
+
+def _findOmegaAndChiToRotateHchiIntoQalpha(h_chi, q_alpha):
+    """
+    (omega, chi) = _findOmegaAndChiToRotateHchiIntoQalpha(H_chi, Q_alpha)
+
+    Solves for omega and chi in OMEGA*CHI*h_chi = q_alpha where h_chi and
+    q_alpha are 3x1 matrices with unit length. Omega and chi are returned in
+    radians.
+
+    Throws an exception if this is not possible.
+    """
+
+    def solve(a, b, c):
+        """
+        x1,x2 =  solve(a , b, c)
+        solves for the two solutions to x in equations of the form
+            a*sin(x) + b*cos(x) = c
+        by using the trigonometric identity
+            a*sin(x) + b*cos(x) = a*sin(x)+b*cos(x)=sqrt(a**2+b**2)-sin(x+p)
+        where
+            p = atan(b/a) + {0 if a>=0
+                            {pi if a<0
+        """
+        if a == 0:
+            p = pi / 2 if b >= 0 else - pi / 2
+        else:
+            p = atan(b / a)
+        if a < 0:
+            p = p + pi
+        guts = c / sqrt(a ** 2 + b ** 2)
+        if guts < -1:
+            guts = -1
+        elif guts > 1:
+            guts = 1
+        left1 = asin(guts)
+        left2 = pi - left1
+        return (left1 - p, left2 - p)
+
+    def ne(a, b):
+        """
+        shifts a and b in between -pi and pi and tests for near equality
+        """
+        def shift(a):
+            if a > pi:
+                return a - 2 * pi
+            elif a <= -pi:
+                return a + 2 * pi
+            else:
+                return a
+        return abs(shift(a) - shift(b)) < .0000001
+
+    # 1. Compute some solutions
+    h_chi1 = h_chi[0, 0]
+    h_chi2 = h_chi[1, 0]
+    h_chi3 = h_chi[2, 0]
+    q_alpha1 = q_alpha[0, 0]
+    q_alpha2 = q_alpha[1, 0]
+    q_alpha3 = q_alpha[2, 0]
+
+    try:
+        # a) Solve for chi using Equation 3
+        chi1, chi2 = solve(-h_chi1, h_chi3, q_alpha3)
+
+        # b) Solve for omega Equation 1 and each chi
+        B = h_chi1 * cos(chi1) + h_chi3 * sin(chi1)
+        eq1omega11, eq1omega12 = solve(h_chi2, B, q_alpha1)
+        B = h_chi1 * cos(chi2) + h_chi3 * sin(chi2)
+        eq1omega21, eq1omega22 = solve(h_chi2, B, q_alpha1)
+
+        # c) Solve for omega Equation 2 and each chi
+        A = -h_chi1 * cos(chi1) - h_chi3 * sin(chi1)
+        eq2omega11, eq2omega12 = solve(A, h_chi2, q_alpha2)
+        A = -h_chi1 * cos(chi2) - h_chi3 * sin(chi2)
+        eq2omega21, eq2omega22 = solve(A, h_chi2, q_alpha2)
+
+    except ValueError, e:
+        raise ValueError(
+            str(e) + ":\nProblem in fixed-phi calculation for:\nh_chi: " +
+            str(h_chi.tolist()) + " q_alpha: " + str(q_alpha.tolist()))
+
+    # 2. Choose values of chi and omega that are solutions to equations 1 and 2
+    solutions = []
+    # a) Check the chi1 solutions
+    print "_findOmegaAndChiToRotateHchiIntoQalpha:"
+    if ne(eq1omega11, eq2omega11) or ne(eq1omega11, eq2omega12):
+#        print "1: eq1omega11, chi1 = ", eq1omega11, chi1
+        solutions.append((eq1omega11, chi1))
+    if ne(eq1omega12, eq2omega11) or ne(eq1omega12, eq2omega12):
+#        print "2: eq1omega12, chi1 = ", eq1omega12, chi1
+        solutions.append((eq1omega12, chi1))
+    # b) Check the chi2 solutions
+    if ne(eq1omega21, eq2omega21) or ne(eq1omega21, eq2omega22):
+#        print "3: eq1omega21, chi2 = ", eq1omega21, chi2
+        solutions.append((eq1omega21, chi2))
+    if ne(eq1omega22, eq2omega21) or ne(eq1omega22, eq2omega22):
+#        print "4: eq1omega22, chi2 = ", eq1omega22, chi2
+        solutions.append((eq1omega22, chi2))
+#    print solutions
+#    print "*"
+
+    if len(solutions) == 0:
+        e = "h_chi: " + str(h_chi.tolist())
+        e += " q_alpha: " + str(q_alpha.tolist())
+        e += ("\nchi1:%4f eq1omega11:%4f eq1omega12:%4f eq2omega11:%4f "
+              "eq2omega12:%4f" % (chi1 * TODEG, eq1omega11 * TODEG,
+              eq1omega12 * TODEG, eq2omega11 * TODEG, eq2omega12 * TODEG))
+        e += ("\nchi2:%4f eq1omega21:%4f eq1omega22:%4f eq2omega21:%4f "
+              "eq2omega22:%4f" % (chi2 * TODEG, eq1omega21 * TODEG,
+              eq1omega22 * TODEG, eq2omega21 * TODEG, eq2omega22 * TODEG))
+        raise Exception("Could not find simultaneous solution for this fixed "
+                        "phi mode problem\n" + e)
+
+    if not PREFER_POSITIVE_CHI_SOLUTIONS:
+        return solutions[0]
+
+    positive_chi_solutions = [sol for sol in solutions if sol[1] > 0]
+
+    if len(positive_chi_solutions) == 0:
+        print "WARNING: A +ve chi solution was requested, but none were found."
+        print "         Returning a -ve one. Try the mapper"
+        return solutions[0]
+
+    if len(positive_chi_solutions) > 1:
+        print ("INFO: Multiple +ve chi solutions were found [(omega, chi) ...]"
+             " = " + str(positive_chi_solutions))
+        print "      Returning the first"
+
+    return positive_chi_solutions[0]
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/constraints.py b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/constraints.py
new file mode 100644
index 0000000..4751bef
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/constraints.py	
@@ -0,0 +1,336 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from copy import copy
+
+from diffcalc.util import DiffcalcException
+
+
+class Mode(object):
+
+    def __init__(self, index, name, group, description, parameterNames,
+                 implemented=True):
+        self.index = index
+        self.group = group
+        self.name = name
+        self.description = description
+        self.parameterNames = parameterNames
+        self.implemented = implemented
+
+    def __repr__(self):
+        return "%i) %s" % (self.index, self.description)
+
+    def __str__(self):
+        return self.__repr__()
+
+    def usesParameter(self, name):
+        return name in self.parameterNames
+
+
+class ModeSelector(object):
+
+    def __init__(self, geometry, parameterManager=None,
+                 gammaParameterName='gamma'):
+        self.parameter_manager = parameterManager
+        self._geometry = geometry
+        self._gammaParameterName = gammaParameterName
+        self._modelist = {}  # indexed by non-contiguous mode number
+        self._configureAvailableModes()
+        self._selectedIndex = 1
+
+    def setParameterManager(self, manager):
+        """
+        Required as a ParameterManager and ModelSelector are mutually tied
+        together in practice
+        """
+        self.parameter_manager = manager
+
+    def _configureAvailableModes(self):
+
+        gammaName = self._gammaParameterName
+
+        ml = self._modelist
+
+        ml[0] = Mode(0, '4cFixedw', 'fourc', 'fourc fixed-bandlw',
+                     ['alpha', gammaName, 'blw'], False)
+
+        ml[1] = Mode(1, '4cBeq', 'fourc', 'fourc bisecting',
+                     ['alpha', gammaName])
+
+        ml[2] = Mode(2, '4cBin', 'fourc', 'fourc incoming',
+                     ['alpha', gammaName, 'betain'])
+
+        ml[3] = Mode(3, '4cBout', 'fourc', 'fourc outgoing',
+                     ['alpha', gammaName, 'betaout'])
+
+        ml[4] = Mode(4, '4cAzimuth', 'fourc', 'fourc azimuth',
+                     ['alpha', gammaName, 'azimuth'], False)
+
+        ml[5] = Mode(5, '4cPhi', 'fourc', 'fourc fixed-phi',
+                     ['alpha', gammaName, 'phi'])
+
+        ml[10] = Mode(10, '5cgBeq', 'fivecFixedGamma', 'fivec bisecting',
+                      [gammaName])
+
+        ml[11] = Mode(11, '5cgBin', 'fivecFixedGamma', 'fivec incoming',
+                      [gammaName, 'betain'])
+
+        ml[12] = Mode(12, '5cgBout', 'fivecFixedGamma', 'fivec outgoing',
+                      [gammaName, 'betaout'])
+
+        ml[13] = Mode(13, '5caBeq', 'fivecFixedAlpha', 'fivec bisecting',
+                      ['alpha'])
+
+        ml[14] = Mode(14, '5caBin', 'fivecFixedAlpha', 'fivec incoming',
+                      ['alpha', 'betain'])
+
+        ml[15] = Mode(15, '5caBout', 'fivecFixedAlpha', 'fivec outgoing',
+                      ['alpha', 'betaout'])
+
+        ml[20] = Mode(20, '6czBeq', 'zaxis', 'zaxis bisecting',
+                      [])
+
+        ml[21] = Mode(21, '6czBin', 'zaxis', 'zaxis incoming',
+                                  ['betain'])
+
+        ml[22] = Mode(22, '6czBout', 'zaxis', 'zaxiz outgoing',
+                                  ['betaout'])
+
+    def setModeByIndex(self, index):
+        if index in self._modelist:
+            self._selectedIndex = index
+        else:
+            raise DiffcalcException("mode %r is not defined" % index)
+
+    def setModeByName(self, name):
+        def findModeWithName(name):
+            for index, mode in self._modelist.items():
+                if mode.name == name:
+                    return index, mode
+            raise ValueError
+
+        try:
+            index, mode = findModeWithName(name)
+        except ValueError:
+            raise DiffcalcException(
+                'Unknown mode. The diffraction calculator supports these '
+                'modeSelector: %s' % self._supportedModes.keys())
+        if  self._geometry.supports_mode_group(mode.group):
+            self._selectedIndex = index
+        else:
+            raise DiffcalcException(
+                "Mode %s not supported for this diffractometer (%s)." %
+                (name, self._geometry.name))
+
+    def getMode(self):
+        return self._modelist[self._selectedIndex]
+
+    def reportCurrentMode(self):
+        return self.getMode().__str__()
+
+    def reportAvailableModes(self):
+        result = ''
+        indecis = self._modelist.keys()
+        indecis.sort()
+        for index in indecis:
+            mode = self._modelist[index]
+            if self._geometry.supports_mode_group(mode.group):
+                paramString = ''
+                flags = ''
+                pm = self.parameter_manager
+                for paramName in pm.getUserChangableParametersForMode(mode):
+                    paramString += paramName + ", "
+                if paramString:
+                    paramString = paramString[:-2]  # remove trailing commas
+                if not mode.implemented:
+                    flags += "(Not impl.)"
+                result += ('%2i) %-15s (%s) %s\n' % (mode.index,
+                           mode.description, paramString, flags))
+        return result
+
+
+class VliegParameterManager(object):
+
+    def __init__(self, geometry, hardware, modeSelector,
+                 gammaParameterName='gamma'):
+        self._geometry = geometry
+        self._hardware = hardware
+        self._modeSelector = modeSelector
+        self._gammaParameterName = gammaParameterName
+        self._parameters = {}
+        self._defineParameters()
+
+    def _defineParameters(self):
+        # Set default fixed values (In degrees if angles)
+        self._parameters = {}
+        self._parameters['alpha'] = 0
+        self._parameters[self._gammaParameterName] = 0
+        self._parameters['blw'] = None  # Busing and Levi omega!
+        self._parameters['betain'] = None
+        self._parameters['betaout'] = None
+        self._parameters['azimuth'] = None
+        self._parameters['phi'] = None
+
+        self._parameterDisplayOrder = (
+            'alpha', self._gammaParameterName, 'betain', 'betaout', 'azimuth',
+            'phi', 'blw')
+        self._trackableParameters = ('alpha', self._gammaParameterName, 'phi')
+        self._trackedParameters = []
+
+        # Overide parameters that are unchangable for this diffractometer
+        for (name, value) in self._geometry.fixed_parameters.items():
+            if name not in self._parameters:
+                raise RuntimeError(
+                    "The %s diffractometer geometry specifies a fixed "
+                    "parameter %s that is not used by the diffractometer "
+                    "calculator" % (self._geometry.getName, name))
+            self._parameters[name] = value
+
+    def reportAllParameters(self):
+        self.update_tracked()
+        result = ''
+        for name in self._parameterDisplayOrder:
+            flags = ""
+            if not self._modeSelector.getMode().usesParameter(name):
+                flags += '(not relevant in this mode)'
+            if self._geometry.parameter_fixed(name):
+                flags += ' (fixed by this diffractometer)'
+            if self.isParameterTracked(name):
+                flags += ' (tracking hardware)'
+            value = self._parameters[name]
+            if value is None:
+                value = '---'
+            else:
+                value = float(value)
+            result += '%s: %s %s\n' % (name.rjust(8), value, flags)
+        return result
+
+    def reportParametersUsedInCurrentMode(self):
+        self.update_tracked()
+        result = ''
+        for name in self.getUserChangableParametersForMode(
+            self._modeSelector.getMode()):
+            flags = ""
+            value = self._parameters[name]
+            if value is None:
+                value = '---'
+            else:
+                value = float(value)
+            if self.isParameterTracked(name):
+                flags += ' (tracking hardware)'
+            result += '%s: %s %s\n' % (name.rjust(8), value, flags)
+        return result
+
+    def getUserChangableParametersForMode(self, mode=None):
+        """
+        (p1,p2...p3) = getUserChangableParametersForMode(mode) returns a list
+        of parameters names used in this mode for this diffractometer geometry.
+        Checks current mode if no mode specified.
+        """
+        if mode is None:
+            mode = self._mode
+        result = []
+        for name in self._parameterDisplayOrder:
+            if self._isParameterChangeable(name, mode):
+                result += [name]
+        return result
+
+### Fixed parameters stuff ###
+
+    def set_constraint(self, name, value):
+        if not name in self._parameters:
+            raise DiffcalcException("No fixed parameter %s is used by the "
+                                    "diffraction calculator" % name)
+        if self._geometry.parameter_fixed(name):
+            raise DiffcalcException(
+                "The parameter %s cannot be changed: It has been fixed by the "
+                "%s diffractometer geometry"
+                % (name, self._geometry.name))
+        if self.isParameterTracked(name):
+            # for safety and to avoid confusion:
+            raise DiffcalcException(
+                "Cannot change parameter %s as it is set to track an axis.\n"
+                "To turn this off use a command like 'trackalpha 0'." % name)
+
+        if not self.isParameterUsedInSelectedMode(name):
+            print ("WARNING: The parameter %s is not used in mode %i" %
+                   (name, self._modeSelector.getMode().index))
+        self._parameters[name] = value
+
+    def isParameterUsedInSelectedMode(self, name):
+        return self._modeSelector.getMode().usesParameter(name)
+
+    def getParameterWithoutUpdatingTrackedParemeters(self, name):
+        try:
+            return self._parameters[name]
+        except KeyError:
+            raise DiffcalcException("No fixed parameter %s is used by the "
+                                    "diffraction calculator" % name)
+
+    def get_constraint(self, name):
+        self.update_tracked()
+        return self.getParameterWithoutUpdatingTrackedParemeters(name)
+
+    def getParameterDict(self):
+        self.update_tracked()
+        return copy(self._parameters)
+
+    @property
+    def settable_constraint_names(self):
+        """list of all available constraints that have settable values"""
+        return sorted(self.getParameterDict().keys())
+
+    def setTrackParameter(self, name, switch):
+        if not name in self._parameters.keys():
+            raise DiffcalcException("No fixed parameter %s is used by the "
+                                    "diffraction calculator" % name)
+        if not name in self._trackableParameters:
+            raise DiffcalcException("Parameter %s is not trackable" % name)
+        if not self._isParameterChangeable(name):
+            print ("WARNING: Parameter %s is not used in mode %i" %
+                   (name, self._mode.index))
+        if switch:
+            if name not in self._trackedParameters:
+                self._trackedParameters.append(name)
+        else:
+            if name in self._trackedParameters:
+                self._trackedParameters.remove(name)
+
+    def isParameterTracked(self, name):
+        return (name in self._trackedParameters)
+
+    def update_tracked(self):
+        """Note that the name of a tracked parameter MUST map into the name of
+        an external diffractometer angle
+        """
+        if self._trackedParameters:
+            externalAnglePositionArray = self._hardware.get_position()
+            externalAngleNames = list(self._hardware.get_axes_names())
+            for name in self._trackedParameters:
+                self._parameters[name] = \
+                    externalAnglePositionArray[externalAngleNames.index(name)]
+
+    def _isParameterChangeable(self, name, mode=None):
+        """
+        Returns true if parameter is used in a mode (current mode if none
+        specified), AND if it is not locked by the diffractometer geometry
+        """
+        if mode is None:
+            mode = self._modeSelector.getMode()
+        return (mode.usesParameter(name) and
+                not self._geometry.parameter_fixed(name))
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/geometry.py b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/geometry.py
new file mode 100644
index 0000000..fc26a83
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/geometry.py	
@@ -0,0 +1,523 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import tan, cos, sin, asin, atan, pi, fabs
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.util import x_rotation, z_rotation, y_rotation
+from diffcalc.util import AbstractPosition
+from diffcalc.util import bound, nearlyEqual
+
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+def calcALPHA(alpha):
+    return x_rotation(alpha)
+
+
+def calcDELTA(delta):
+    return z_rotation(-delta)
+
+
+def calcGAMMA(gamma):
+    return x_rotation(gamma)
+
+
+def calcOMEGA(omega):
+    return z_rotation(-omega)
+
+
+def calcCHI(chi):
+    return y_rotation(chi)
+
+
+def calcPHI(phi):
+    return z_rotation(-phi)
+
+
+def createVliegMatrices(alpha=None, delta=None, gamma=None, omega=None,
+                        chi=None, phi=None):
+
+    ALPHA = None if alpha is None else calcALPHA(alpha)
+    DELTA = None if delta is None else calcDELTA(delta)
+    GAMMA = None if gamma is None else calcGAMMA(gamma)
+    OMEGA = None if omega is None else calcOMEGA(omega)
+    CHI = None if chi is None else calcCHI(chi)
+    PHI = None if phi is None else calcPHI(phi)
+    return ALPHA, DELTA, GAMMA, OMEGA, CHI, PHI
+
+
+def createVliegsSurfaceTransformationMatrices(sigma, tau):
+    """[SIGMA, TAU] = createVliegsSurfaceTransformationMatrices(sigma, tau)
+    angles in radians
+    """
+    SIGMA = matrix([[cos(sigma), 0, sin(sigma)],
+                    [0, 1, 0], \
+                    [-sin(sigma), 0, cos(sigma)]])
+
+    TAU = matrix([[cos(tau), sin(tau), 0],
+                  [-sin(tau), cos(tau), 0],
+                  [0, 0, 1]])
+    return(SIGMA, TAU)
+
+
+def createVliegsPsiTransformationMatrix(psi):
+    """PSI = createPsiTransformationMatrices(psi)
+    angles in radians
+    """
+    return matrix([[1, 0, 0],
+                   [0, cos(psi), sin(psi)],
+                   [0, -sin(psi), cos(psi)]])
+
+
+class VliegPosition(AbstractPosition):
+    """The position of all six diffractometer axis"""
+    def __init__(self, alpha=None, delta=None, gamma=None, omega=None,
+                 chi=None, phi=None):
+        self.alpha = alpha
+        self.delta = delta
+        self.gamma = gamma
+        self.omega = omega
+        self.chi = chi
+        self.phi = phi
+
+    def clone(self):
+        return VliegPosition(self.alpha, self.delta, self.gamma, self.omega,
+                             self.chi, self.phi)
+
+    def changeToRadians(self):
+        self.alpha *= TORAD
+        self.delta *= TORAD
+        self.gamma *= TORAD
+        self.omega *= TORAD
+        self.chi *= TORAD
+        self.phi *= TORAD
+
+    def changeToDegrees(self):
+        self.alpha *= TODEG
+        self.delta *= TODEG
+        self.gamma *= TODEG
+        self.omega *= TODEG
+        self.chi *= TODEG
+        self.phi *= TODEG
+
+    def inRadians(self):
+        pos = self.clone()
+        pos.changeToRadians()
+        return pos
+
+    def inDegrees(self):
+        pos = self.clone()
+        pos.changeToDegrees()
+        return pos
+
+    def nearlyEquals(self, pos2, maxnorm):
+        for a, b in zip(self.totuple(), pos2.totuple()):
+            if abs(a - b) > maxnorm:
+                return False
+        return True
+
+    def totuple(self):
+        return (self.alpha, self.delta, self.gamma, self.omega,
+                self.chi, self.phi)
+
+    def __str__(self):
+        return ("VliegPosition(alpha %r delta: %r gamma: %r omega: %r chi: %r"
+                "  phi: %r)" % self.totuple())
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, b):
+        return self.nearlyEquals(b, .001)
+
+
+class VliegGeometry(object):
+
+# Required methods
+
+    def __init__(self, name, supported_mode_groups, fixed_parameters,
+                 gamma_location):
+        """
+        Set geometry name (String), list of supported mode groups (list of
+        strings), list of axis names (list of strings). Define the parameters
+        e.g. alpha and gamma for a four circle (dictionary). Define wether the
+        gamma angle is on the 'arm' or the 'base'; used only by AngleCalculator
+        to interpret the gamma parameter in fixed gamma mode: for instruments
+        with gamma on the base, rather than on the arm as the code assume
+        internally, the two methods physical_angles_to_internal_position and
+        internal_position_to_physical_angles must still be used.
+        """
+        if gamma_location not in ('arm', 'base', None):
+            raise RuntimeError(
+                "Gamma must be on either 'arm' or 'base' or None")
+
+        self.name = name
+        self.supported_mode_groups = supported_mode_groups
+        self.fixed_parameters = fixed_parameters
+        self.gamma_location = gamma_location
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        raise NotImplementedError()
+
+    def internal_position_to_physical_angles(self, physicalAngles):
+        raise NotImplementedError()
+
+### Do not overide these these ###
+
+    def supports_mode_group(self, name):
+        return name in self.supported_mode_groups
+
+    def parameter_fixed(self, name):  # parameter_fixed
+        return name in self.fixed_parameters.keys()
+
+
+class SixCircleGammaOnArmGeometry(VliegGeometry):
+    """
+    This six-circle diffractometer geometry simply passes through the
+    angles from a six circle diffractometer with the same geometry and
+    angle names as those defined in Vliegs's paper defined internally.
+    """
+
+    def __init__(self):
+        VliegGeometry.__init__(
+            self,
+            name='sixc_gamma_on_arm',
+            supported_mode_groups=('fourc', 'fivecFixedGamma',
+                                    'fivecFixedAlpha', 'zaxis'),
+            fixed_parameters={},
+            gamma_location='arm')
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        assert (len(physicalAngles) == 6), "Wrong length of input list"
+        return VliegPosition(*physicalAngles)
+
+    def internal_position_to_physical_angles(self, internalPosition):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        return internalPosition.totuple()
+
+
+class SixCircleGeometry(VliegGeometry):
+    """
+    This six-circle diffractometer geometry simply passes through the
+    angles from a six circle diffractometer with the same geometry and
+    angle names as those defined in Vliegs's paper defined internally.
+    """
+
+    def __init__(self):
+        VliegGeometry.__init__(
+            self,
+            name='sixc',
+            supported_mode_groups=('fourc', 'fivecFixedGamma',
+                                    'fivecFixedAlpha', 'zaxis'),
+            fixed_parameters={},
+            gamma_location='base')
+        self.hardwareMonitor = None
+#(deltaA, gammaA) = gammaOnBaseToArm(deltaB, gammaB, alpha) (all in radians)
+#(deltaB, gammaB) = gammaOnArmToBase(deltaA, gammaA, alpha) (all in radians)
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        assert (len(physicalAngles) == 6), "Wrong length of input list"
+        alpha, deltaB, gammaB, omega, chi, phi = physicalAngles
+        (deltaA, gammaA) = gammaOnBaseToArm(
+            deltaB * TORAD, gammaB * TORAD, alpha * TORAD)
+        return VliegPosition(
+            alpha, deltaA * TODEG, gammaA * TODEG, omega, chi, phi)
+
+    def internal_position_to_physical_angles(self, internalPosition):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        alpha, deltaA, gammaA, omega, chi, phi = internalPosition.totuple()
+        deltaB, gammaB = gammaOnArmToBase(
+            deltaA * TORAD, gammaA * TORAD, alpha * TORAD)
+        deltaB, gammaB = deltaB * TODEG, gammaB * TODEG
+
+        if self.hardwareMonitor is not None:
+            gammaName = self.hardwareMonitor.get_axes_names()[2]
+            minGamma = self.hardwareMonitor.get_lower_limit(gammaName)
+            maxGamma = self.hardwareMonitor.get_upper_limit(gammaName)
+
+            if maxGamma is not None:
+                if gammaB > maxGamma:
+                    gammaB = gammaB - 180
+                    deltaB = 180 - deltaB
+            if minGamma is not None:
+                if gammaB < minGamma:
+                    gammaB = gammaB + 180
+                    deltaB = 180 - deltaB
+
+        return alpha, deltaB, gammaB, omega, chi, phi
+
+
+class FivecWithGammaOnBase(SixCircleGeometry):
+
+    def __init__(self):
+        VliegGeometry.__init__(
+            self,
+            name='fivec_with_gamma',
+            supported_mode_groups=('fourc', 'fivecFixedGamma'),
+            fixed_parameters={'alpha': 0.0},
+            gamma_location='base')
+        self.hardwareMonitor = None
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(d,g,o,c,p)
+        """
+        assert (len(physicalAngles) == 5), "Wrong length of input list"
+        return SixCircleGeometry.physical_angles_to_internal_position(
+            self, (0,) + tuple(physicalAngles))
+
+    def internal_position_to_physical_angles(self, internalPosition):
+        """ (d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        return SixCircleGeometry.internal_position_to_physical_angles(
+            self, internalPosition)[1:]
+
+
+class Fivec(VliegGeometry):
+    """
+    This five-circle diffractometer geometry is for diffractometers with the
+    same geometry and angle names as those defined in Vliegs's paper defined
+    internally, but with no out plane detector arm  gamma."""
+
+    def __init__(self):
+        VliegGeometry.__init__(self,
+                    name='fivec',
+                    supported_mode_groups=('fourc', 'fivecFixedGamma'),
+                    fixed_parameters={'gamma': 0.0},
+                    gamma_location='arm'
+        )
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        assert (len(physicalAngles) == 5), "Wrong length of input list"
+        physicalAngles = tuple(physicalAngles)
+        angles = physicalAngles[0:2] + (0.0,) + physicalAngles[2:]
+        return VliegPosition(*angles)
+
+    def internal_position_to_physical_angles(self, internalPosition):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        sixAngles = internalPosition.totuple()
+        return sixAngles[0:2] + sixAngles[3:]
+
+
+class Fourc(VliegGeometry):
+    """
+    This five-circle diffractometer geometry is for diffractometers with the
+    same geometry and angle names as those defined in Vliegs's paper defined
+    internally, but with no out plane detector arm  gamma."""
+
+    def __init__(self):
+        VliegGeometry.__init__(self,
+                    name='fourc',
+                    supported_mode_groups=('fourc'),
+                    fixed_parameters={'gamma': 0.0, 'alpha': 0.0},
+                    gamma_location='arm'
+        )
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        assert (len(physicalAngles) == 4), "Wrong length of input list"
+        physicalAngles = tuple(physicalAngles)
+        angles = (0.0, physicalAngles[0], 0.0) + physicalAngles[1:]
+        return VliegPosition(*angles)
+
+    def internal_position_to_physical_angles(self, internalPosition):
+        """ (a,d,g,o,c,p) = physicalAnglesToInternal(a,d,g,o,c,p)
+        """
+        sixAngles = internalPosition.totuple()
+        return sixAngles[1:2] + sixAngles[3:]
+
+
+def sign(x):
+    if x < 0:
+        return -1
+    else:
+        return 1
+
+"""
+Based on: Elias Vlieg, "A (2+3)-Type Surface Diffractometer: Mergence of
+the z-axis and (2+2)-Type Geometries", J. Appl. Cryst. (1998). 31.
+198-203
+"""
+
+
+def solvesEq8(alpha, deltaA, gammaA, deltaB, gammaB):
+    tol = 1e-6
+    return (nearlyEqual(sin(deltaA) * cos(gammaA), sin(deltaB), tol) and
+        nearlyEqual(cos(deltaA) * cos(gammaA),
+                    cos(gammaB - alpha) * cos(deltaB), tol) and
+        nearlyEqual(sin(gammaA), sin(gammaB - alpha) * cos(deltaB), tol))
+
+
+GAMMAONBASETOARM_WARNING = '''
+WARNING: This diffractometer has the gamma circle attached to the
+         base rather than the end of
+         the delta arm as Vlieg's paper defines. A conversion has
+         been made from the physical angles to their internal
+         representation (gamma-on-base-to-arm). This conversion has
+         forced gamma to be positive by applying the mapping:
+
+         delta --> 180+delta
+         gamma --> 180+gamma.
+
+         This should have no adverse effect.
+'''
+
+
+def gammaOnBaseToArm(deltaB, gammaB, alpha):
+    """
+    (deltaA, gammaA) = gammaOnBaseToArm(deltaB, gammaB, alpha) (all in
+    radians)
+
+    Maps delta and gamma for an instrument where the gamma circle rests on
+    the base to the case where it is on the delta arm.
+
+    There are always two possible solutions. To get the second apply the
+    transform:
+
+        delta --> 180+delta (flip to opposite side of circle)
+        gamma --> 180+gamma (flip to opposite side of circle)
+
+    This code will return the solution where gamma is between 0 and 180.
+    """
+
+    ### Equation11 ###
+    if fabs(cos(gammaB - alpha)) < 1e-20:
+        deltaA1 = sign(tan(deltaB)) * sign(cos(gammaB - alpha)) * pi / 2
+    else:
+        deltaA1 = atan(tan(deltaB) / cos(gammaB - alpha))
+    # ...second root
+    if deltaA1 <= 0:
+        deltaA2 = deltaA1 + pi
+    else:
+        deltaA2 = deltaA1 - pi
+
+    ### Equation 12 ###
+    gammaA1 = asin(bound(cos(deltaB) * sin(gammaB - alpha)))
+    # ...second root
+    if gammaA1 >= 0:
+        gammaA2 = pi - gammaA1
+    else:
+        gammaA2 = -pi - gammaA1
+
+    # Choose the delta solution that fits equations 8
+    if solvesEq8(alpha, deltaA1, gammaA1, deltaB, gammaB):
+        deltaA, gammaA = deltaA1, gammaA1
+    elif solvesEq8(alpha, deltaA2, gammaA1, deltaB, gammaB):
+        deltaA, gammaA = deltaA2, gammaA1
+        print "gammaOnBaseToArm choosing 2nd delta root (to internal)"
+    elif solvesEq8(alpha, deltaA1, gammaA2, deltaB, gammaB):
+        print "gammaOnBaseToArm choosing 2nd gamma root (to internal)"
+        deltaA, gammaA = deltaA1, gammaA2
+    elif solvesEq8(alpha, deltaA2, gammaA2, deltaB, gammaB):
+        print "gammaOnBaseToArm choosing 2nd delta root and 2nd gamma root"
+        deltaA, gammaA = deltaA2, gammaA2
+    else:
+        raise RuntimeError(
+         "No valid solutions found mapping from gamma-on-base to gamma-on-arm")
+
+    return deltaA, gammaA
+
+GAMMAONARMTOBASE_WARNING = '''
+        WARNING: This diffractometer has the gamma circle attached to the base
+                 rather than the end of the delta arm as Vlieg's paper defines.
+                 A conversion has been made from the internal representation of
+                 angles to physical angles (gamma-on-arm-to-base). This
+                 conversion has forced gamma to be positive by applying the
+                 mapping:
+
+                    delta --> 180-delta
+                    gamma --> 180+gamma.
+
+                 This should have no adverse effect.
+'''
+
+
+def gammaOnArmToBase(deltaA, gammaA, alpha):
+    """
+    (deltaB, gammaB) = gammaOnArmToBase(deltaA, gammaA, alpha) (all in
+    radians)
+
+    Maps delta and gamma for an instrument where the gamma circle is on
+    the delta arm to the case where it rests on the base.
+
+    There are always two possible solutions. To get the second apply the
+    transform:
+
+        delta --> 180-delta (reflect and flip to opposite side)
+        gamma --> 180+gamma (flip to opposite side)
+
+    This code will return the solution where gamma is positive, but will
+    warn if a sign change was made.
+    """
+
+    ### Equation 9 ###
+    deltaB1 = asin(bound(sin(deltaA) * cos(gammaA)))
+    # ...second root:
+    if deltaB1 >= 0:
+        deltaB2 = pi - deltaB1
+    else:
+        deltaB2 = -pi - deltaB1
+
+    ### Equation 10 ###:
+    if fabs(cos(deltaA)) < 1e-20:
+        gammaB1 = sign(tan(gammaA)) * sign(cos(deltaA)) * pi / 2 + alpha
+    else:
+        gammaB1 = atan(tan(gammaA) / cos(deltaA)) + alpha
+    #... second root:
+    if gammaB1 <= 0:
+        gammaB2 = gammaB1 + pi
+    else:
+        gammaB2 = gammaB1 - pi
+
+    ### Choose the solution that fits equation 8 ###
+    if (solvesEq8(alpha, deltaA, gammaA, deltaB1, gammaB1) and
+        0 <= gammaB1 <= pi):
+        deltaB, gammaB = deltaB1, gammaB1
+    elif (solvesEq8(alpha, deltaA, gammaA, deltaB2, gammaB1) and
+          0 <= gammaB1 <= pi):
+        deltaB, gammaB = deltaB2, gammaB1
+        print "gammaOnArmToBase choosing 2nd delta root (to physical)"
+    elif (solvesEq8(alpha, deltaA, gammaA, deltaB1, gammaB2) and
+          0 <= gammaB2 <= pi):
+        print "gammaOnArmToBase choosing 2nd gamma root (to physical)"
+        deltaB, gammaB = deltaB1, gammaB2
+    elif (solvesEq8(alpha, deltaA, gammaA, deltaB2, gammaB2)
+          and 0 <= gammaB2 <= pi):
+        print "gammaOnArmToBase choosing 2nd delta root and 2nd gamma root"
+        deltaB, gammaB = deltaB2, gammaB2
+    else:
+        raise RuntimeError(
+            "No valid solutions found mapping gamma-on-arm to gamma-on-base")
+
+    return deltaB, gammaB
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/hkl.py b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/hkl.py
new file mode 100644
index 0000000..ae05018
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/hkl.py	
@@ -0,0 +1,139 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc.hkl.common import getNameFromScannableOrString
+from diffcalc.util import command
+from diffcalc import settings
+
+
+from diffcalc.ub import ub
+from diffcalc.hkl.vlieg.calc import VliegHklCalculator
+
+
+__all__ = ['hklmode', 'setpar', 'trackalpha', 'trackgamma', 'trackphi',
+           'parameter_manager', 'hklcalc']
+
+
+hklcalc = VliegHklCalculator(ub.ubcalc, settings.geometry, settings.hardware)
+
+parameter_manager = hklcalc.parameter_manager
+
+def __str__(self):
+    return hklcalc.__str__()
+
+@command
+def hklmode(num=None):
+    """hklmode {num} -- changes mode or shows current and available modes and all settings""" #@IgnorePep8
+
+    if num is None:
+        print hklcalc.__str__()
+    else:
+        hklcalc.mode_selector.setModeByIndex(int(num))
+        pm = hklcalc.parameter_manager
+        print (hklcalc.mode_selector.reportCurrentMode() + "\n" +
+               pm.reportParametersUsedInCurrentMode())
+
+def _setParameter(name, value):
+    hklcalc.parameter_manager.set_constraint(name, value)
+
+def _getParameter(name):
+    return hklcalc.parameter_manager.get_constraint(name)
+
+@command
+def setpar(scannable_or_string=None, val=None):
+    """setpar {parameter_scannable {{val}} -- sets or shows a parameter'
+    setpar {parameter_name {val}} -- sets or shows a parameter'
+    """
+
+    if scannable_or_string is None:
+        #show all
+        parameterDict = hklcalc.parameter_manager.getParameterDict()
+        names = parameterDict.keys()
+        names.sort()
+        for name in names:
+            print _representParameter(name)
+    else:
+        name = getNameFromScannableOrString(scannable_or_string)
+        if val is None:
+            _representParameter(name)
+        else:
+            oldval = _getParameter(name)
+            _setParameter(name, float(val))
+            print _representParameter(name, oldval, float(val))
+
+def _representParameter(name, oldval=None, newval=None):
+    flags = ''
+    if hklcalc.parameter_manager.isParameterTracked(name):
+        flags += '(tracking hardware) '
+    if settings.geometry.parameter_fixed(name):  # @UndefinedVariable
+        flags += '(fixed by geometry) '
+    pm = hklcalc.parameter_manager
+    if not pm.isParameterUsedInSelectedMode(name):
+        flags += '(not relevant in this mode) '
+    if oldval is None:
+        val = _getParameter(name)
+        if val is None:
+            val = "---"
+        else:
+            val = str(val)
+        return "%s: %s %s" % (name, val, flags)
+    else:
+        return "%s: %s --> %f %s" % (name, oldval, newval, flags)
+
+def _checkInputAndSetOrShowParameterTracking(name, b=None):
+    """
+    for track-parameter commands: If no args displays parameter settings,
+    otherwise sets the tracking switch for the given parameter and displays
+    settings.
+    """
+    # set if arg given
+    if b is not None:
+        hklcalc.parameter_manager.setTrackParameter(name, b)
+    # Display:
+    lastValue = _getParameter(name)
+    if lastValue is None:
+        lastValue = "---"
+    else:
+        lastValue = str(lastValue)
+    flags = ''
+    if hklcalc.parameter_manager.isParameterTracked(name):
+        flags += '(tracking hardware)'
+    print "%s: %s %s" % (name, lastValue, flags)
+
+@command
+def trackalpha(b=None):
+    """trackalpha {boolean} -- determines wether alpha parameter will track alpha axis""" #@IgnorePep8
+    _checkInputAndSetOrShowParameterTracking('alpha', b)
+
+@command
+def trackgamma(b=None):
+    """trackgamma {boolean} -- determines wether gamma parameter will track alpha axis""" #@IgnorePep8
+    _checkInputAndSetOrShowParameterTracking('gamma', b)
+
+@command
+def trackphi(b=None):
+    """trackphi {boolean} -- determines wether phi parameter will track phi axis""" #@IgnorePep8
+    _checkInputAndSetOrShowParameterTracking('phi', b)
+  
+  
+commands_for_help = ['Mode',
+                     hklmode,
+                     setpar,
+                     trackalpha,
+                     trackgamma,
+                     trackphi]
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/transform.py b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/transform.py
new file mode 100644
index 0000000..a41e8b9
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/vlieg/transform.py	
@@ -0,0 +1,480 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc.util import command
+
+from copy import copy
+from math import pi
+
+from diffcalc.hkl.vlieg.geometry import VliegPosition as P
+
+SMALL = 1e-10
+
+
+class Transform(object):
+
+    def transform(self, pos):
+        raise RuntimeError('Not implemented')
+
+
+### Transforms, currently for definition and testing the theory only
+
+class TransformC(Transform):
+    '''Flip omega, invert chi and flip phi
+    '''
+    def transform(self, pos):
+        pos = pos.clone()
+        pos.omega -= 180
+        pos.chi *= -1
+        pos.phi -= 180
+        return pos
+
+
+class TransformB(Transform):
+    '''Flip chi, and invert and flip omega
+    '''
+    def transform(self, pos):
+        pos = pos.clone()
+        pos.chi -= 180
+        pos.omega = 180 - pos.omega
+        return pos
+
+
+class TransformA(Transform):
+    '''Invert scattering plane: invert delta and omega and flip chi'''
+    def transform(self, pos):
+        pos = pos.clone()
+        pos.delta *= -1
+        pos.omega *= -1
+        pos.chi -= 180
+        return pos
+
+
+class TransformCInRadians(Transform):
+    '''
+    Flip omega, invert chi and flip phi. Using radians and keeping
+    -pi<omega<=pi and 0<=phi<=360
+    '''
+    def transform(self, pos):
+        pos = pos.clone()
+        if pos.omega > 0:
+            pos.omega -= pi
+        else:
+            pos.omega += pi
+        pos.chi *= -1
+        pos.phi += pi
+        return pos
+
+
+###
+
+transformsFromSector = {
+    0: (),
+    1: ('c',),
+    2: ('a',),
+    3: ('a', 'c'),
+    4: ('b', 'c'),
+    5: ('b',),
+    6: ('a', 'b', 'c'),
+    7: ('a', 'b')
+}
+
+sectorFromTransforms = {}
+for k, v in transformsFromSector.iteritems():
+    sectorFromTransforms[v] = k
+
+
+class VliegPositionTransformer(object):
+
+    def __init__(self, geometry, hardware, solution_transformer):
+        self._geometry = geometry
+        self._hardware = hardware
+        self._solution_transformer = solution_transformer
+        solution_transformer.limitCheckerFunction = self.is_position_within_limits
+
+    def transform(self, pos):
+        # 1. Choose the correct sector/transforms
+        return self._solution_transformer.transformPosition(pos)
+
+    def is_position_within_limits(self, position):
+        '''where position is Position object in degrees'''
+        angleTuple = self._geometry.internal_position_to_physical_angles(position)
+        angleTuple = self._hardware.cut_angles(angleTuple)
+        return self._hardware.is_position_within_limits(angleTuple)
+
+
+class VliegTransformSelector(object):
+    '''All returned angles are between -180. and 180. -180.<=angle<180.
+    '''
+### basic sector selection
+
+    def __init__(self):
+        self.transforms = []
+        self.autotransforms = []
+        self.autosectors = []
+        self.limitCheckerFunction = None  # inject
+        self.sector = None
+        self.setSector(0)
+
+    def setSector(self, sector):
+        if not 0 <= sector <= 7:
+            raise ValueError('%i must between 0 and 7.' % sector)
+        self.sector = sector
+        self.transforms = list(transformsFromSector[sector])
+
+    def setTransforms(self, transformList):
+        transformList = list(transformList)
+        transformList.sort()
+        self.sector = sectorFromTransforms[tuple(transformList)]
+        self.transforms = transformList
+
+    def addTransorm(self, transformName):
+        if transformName not in ('a', 'b', 'c'):
+            raise ValueError('%s is not a recognised transform. Try a, b or c'
+                             % transformName)
+        if transformName in self.transforms:
+            print "WARNING, transform %s is already selected"
+        else:
+            self.setTransforms(self.transforms + [transformName])
+
+    def removeTransorm(self, transformName):
+        if transformName not in ('a', 'b', 'c'):
+            raise ValueError('%s is not a recognised transform. Try a, b or c'
+                             % transformName)
+        if transformName in self.transforms:
+            new = copy(self.transforms)
+            new.remove(transformName)
+            self.setTransforms(new)
+        else:
+            print "WARNING, transform %s was not selected" % transformName
+
+    def addAutoTransorm(self, transformOrSector):
+        '''
+        If input is a string (letter), tags one of the transofrms as being a
+        candidate for auto application. If a number, tags a sector as being a
+        candidate for auto application, and removes similar tags for any
+        transforms (as the two are incompatable).
+        '''
+        if type(transformOrSector) == str:
+            transform = transformOrSector
+            if transform not in ('a', 'b', 'c'):
+                raise ValueError(
+                    '%s is not a recognised transform. Try a, b or c' %
+                    transform)
+            if transform not in self.autotransforms:
+                self.autosectors = []
+                self.autotransforms.append(transform)
+            else:
+                print "WARNING: %s is already set to auto apply" % transform
+        elif type(transformOrSector) == int:
+            sector = transformOrSector
+            if not 0 <= sector <= 7:
+                raise ValueError('%i must between 0 and 7.' % sector)
+            if sector not in self.autosectors:
+                self.autotransforms = []
+                self.autosectors.append(sector)
+            else:
+                print "WARNING: %i is already set to auto apply" % sector
+        else:
+            raise ValueError("Input must be 'a', 'b' or 'c', "
+                             "or 1,2,3,4,5,6 or 7.")
+
+    def removeAutoTransform(self, transformOrSector):
+        if type(transformOrSector) == str:
+            transform = transformOrSector
+            if transform not in ('a', 'b', 'c'):
+                raise ValueError("%s is not a recognised transform. "
+                                 "Try a, b or c" % transform)
+            if transform in self.autotransforms:
+                self.autotransforms.remove(transform)
+            else:
+                print "WARNING: %s is not set to auto apply" % transform
+        elif type(transformOrSector) == int:
+            sector = transformOrSector
+            if not 0 <= sector <= 7:
+                raise ValueError('%i must between 0 and 7.' % sector)
+            if sector in self.autosectors:
+                self.autosectors.remove(sector)
+            else:
+                print "WARNING: %s is not set to auto apply" % sector
+        else:
+            raise ValueError("Input must be 'a', 'b' or 'c', "
+                             "or 1,2,3,4,5,6 or 7.")
+
+    def setAutoSectors(self, sectorList):
+        for sector in sectorList:
+            if not 0 <= sector <= 7:
+                raise ValueError('%i must between 0 and 7.' % sector)
+        self.autosectors = list(sectorList)
+
+    def transformPosition(self, pos):
+        pos = self.transformNWithoutCut(self.sector, pos)
+        cutpos = self.cutPosition(pos)
+        # -180 <= cutpos < 180, NOT the externally applied cuts
+        if len(self.autosectors) > 0:
+            if self.is_position_within_limits(cutpos):
+                return cutpos
+            else:
+                return self.autoTransformPositionBySector(cutpos)
+        if len(self.autotransforms) > 0:
+            if self.is_position_within_limits(cutpos):
+                return cutpos
+            else:
+                return self.autoTransformPositionByTransforms(pos)
+        #else
+        return cutpos
+
+    def transformNWithoutCut(self, n, pos):
+
+        if n == 0:
+            return P(pos.alpha, pos.delta, pos.gamma,
+                     pos.omega, pos.chi, pos.phi)
+        if n == 1:
+            return P(pos.alpha, pos.delta, pos.gamma,
+                     pos.omega - 180., -pos.chi, pos.phi - 180.)
+        if n == 2:
+            return P(pos.alpha, -pos.delta, pos.gamma,
+                     -pos.omega, pos.chi - 180., pos.phi)
+        if n == 3:
+            return P(pos.alpha, -pos.delta, pos.gamma,
+                     180. - pos.omega, 180. - pos.chi, pos.phi - 180.)
+        if n == 4:
+            return P(pos.alpha, pos.delta, pos.gamma,
+                     -pos.omega, 180. - pos.chi, pos.phi - 180.)
+        if n == 5:
+            return P(pos.alpha, pos.delta, pos.gamma,
+                     180. - pos.omega, pos.chi - 180., pos.phi)
+        if n == 6:
+            return P(pos.alpha, -pos.delta, pos.gamma,
+                     pos.omega, -pos.chi, pos.phi - 180.)
+        if n == 7:
+            return P(pos.alpha, -pos.delta, pos.gamma,
+                     pos.omega - 180., pos.chi, pos.phi)
+        else:
+            raise Exception("sector must be between 0 and 7")
+
+### autosector
+
+    def hasAutoSectorsOrTransformsToApply(self):
+        return len(self.autosectors) > 0 or len(self.autotransforms) > 0
+
+    def autoTransformPositionBySector(self, pos):
+        okaysectors = []
+        okaypositions = []
+        for sector in self.autosectors:
+            newpos = self.transformNWithoutCut(sector, pos)
+            if self.is_position_within_limits(newpos):
+                okaysectors.append(sector)
+                okaypositions.append(newpos)
+        if len(okaysectors) == 0:
+            raise Exception(
+                "Autosector could not find a sector (from %s) to move %s into "
+                "limits." % (self.autosectors, str(pos)))
+        if len(okaysectors) > 1:
+            print ("WARNING: Autosector found multiple sectors that would "
+                   "move %s to move into limits: %s" % (str(pos), okaysectors))
+
+        print ("INFO: Autosector changed sector from %i to %i" %
+               (self.sector, okaysectors[0]))
+        self.sector = okaysectors[0]
+        return okaypositions[0]
+
+    def autoTransformPositionByTransforms(self, pos):
+        possibleTransforms = self.createListOfPossibleTransforms()
+        okaytransforms = []
+        okaypositions = []
+        for transforms in possibleTransforms:
+            sector = sectorFromTransforms[tuple(transforms)]
+            newpos = self.cutPosition(self.transformNWithoutCut(sector, pos))
+            if self.is_position_within_limits(newpos):
+                okaytransforms.append(transforms)
+                okaypositions.append(newpos)
+        if len(okaytransforms) == 0:
+            raise Exception(
+                "Autosector could not find a sector (from %r) to move %r into "
+                "limits." % (self.autosectors, pos))
+        if len(okaytransforms) > 1:
+            print ("WARNING: Autosector found multiple sectors that would "
+                   "move %s to move into limits: %s" %
+                   (repr(pos), repr(okaytransforms)))
+
+        print ("INFO: Autosector changed selected transforms from %r to %r" %
+               (self.transforms, okaytransforms[0]))
+        self.setTransforms(okaytransforms[0])
+        return okaypositions[0]
+
+    def createListOfPossibleTransforms(self):
+        def vary(possibleTransforms, name):
+            result = []
+            for transforms in possibleTransforms:
+                # add the original.
+                result.append(transforms)
+                # add a modified one
+                toadd = list(copy(transforms))
+                if name in transforms:
+                    toadd.remove(name)
+                else:
+                    toadd.append(name)
+                toadd.sort()
+                result.append(toadd)
+            return result
+        # start with the currently selected list of transforms
+        if len(self.transforms) == 0:
+            possibleTransforms = [()]
+        else:
+            possibleTransforms = copy(self.transforms)
+
+        for name in self.autotransforms:
+            possibleTransforms = vary(possibleTransforms, name)
+
+        return possibleTransforms
+
+    def is_position_within_limits(self, pos):
+        '''where pos os a poistion object in degrees'''
+        return self.limitCheckerFunction(pos)
+
+    def __repr__(self):
+        def createPrefix(transform):
+            if transform in self.transforms:
+                s = '*on* '
+            else:
+                s = 'off  '
+            if len(self.autotransforms) > 0:
+                if transform in self.autotransforms:
+                    s += '*auto*'
+                else:
+                    s += '      '
+            return s
+        s = 'Transforms/sector:\n'
+        s += ('  %s (a transform) Invert scattering plane: invert delta and '
+              'omega and flip chi\n' % createPrefix('a'))
+        s += ('  %s (b transform) Flip chi, and invert and flip omega\n' %
+              createPrefix('b'))
+        s += ('  %s (c transform) Flip omega, invert chi and flip phi\n' %
+              createPrefix('c'))
+        s += '  Current sector: %i (Spec fourc equivalent)\n' % self.sector
+        if len(self.autosectors) > 0:
+            s += '  Auto sectors: %s\n' % self.autosectors
+        return s
+
+    def cutPosition(self, position):
+        '''Cuts angles at -180.; moves each argument between -180. and 180.
+        '''
+        def cut(a):
+            if a is None:
+                return None
+            else:
+                if a < (-180. - SMALL):
+                    return a + 360.
+                if a > (180. + SMALL):
+                    return a - 360.
+            return a
+        return P(cut(position.alpha), cut(position.delta), cut(position.gamma),
+                 cut(position.omega), cut(position.chi), cut(position.phi))
+
+
+def getNameFromScannableOrString(o):
+        try:  # it may be a scannable
+            return o.getName()
+        except AttributeError:
+            return str(o)
+
+
+class TransformCommands(object):
+
+    def __init__(self, sector_selector):
+        self._sectorSelector = sector_selector
+
+    @command
+    def transform(self):
+        """transform  -- show transform configuration"""
+        print self._sectorSelector.__repr__()
+
+    @command
+    def transforma(self, *args):
+        """transforma {on|off|auto|manual} -- configure transform A application
+        """
+        self._transform('transforma', 'a', args)
+
+    @command
+    def transformb(self, *args):
+        """transformb {on|off|auto|manual} -- configure transform B application
+        """
+        self._transform('transformb', 'b', args)
+
+    @command
+    def transformc(self, *args):
+        """transformc {on|off|auto|manual} -- configure transform C application
+        """
+
+        self._transform('transformc', 'c', args)
+
+    def _transform(self, commandName, transformName, args):
+        if len(args) == 0:
+            print self._sectorSelector.__repr__()
+            return
+        # get name
+        if len(args) != 1:
+            raise TypeError()
+        if type(args[0]) is not str:
+            raise TypeError()
+
+        ss = self._sectorSelector
+        if args[0] == 'on':
+            ss.addTransorm(transformName)
+        elif args[0] == 'off':
+            ss.removeTransorm(transformName)
+        elif args[0] == 'auto':
+            ss.addAutoTransorm(transformName)
+        elif args[0] == 'manual':
+            ss.removeAutoTransform(transformName)
+        else:
+            raise TypeError()
+        print self._sectorSelector.__repr__()
+
+    @command
+    def sector(self, sector=None):
+        """sector {0-7} -- Select or display sector (a la Spec)
+        """
+        if sector is None:
+            print self._sectorSelector.__repr__()
+        else:
+            if type(sector) is not int and not (0 <= sector <= 7):
+                raise TypeError()
+            self._sectorSelector.setSector(sector)
+            print self._sectorSelector.__repr__()
+
+    @command
+    def autosector(self, *args):
+        """autosector [None] [0-7] [0-7]... -- Set sectors that might be automatically applied""" #@IgnorePep8
+        if len(args) == 0:
+            print self._sectorSelector.__repr__()
+        elif len(args) == 1 and args[0] is None:
+            self._sectorSelector.setAutoSectors([])
+            print self._sectorSelector.__repr__()
+        else:
+            sectorList = []
+            for arg in args:
+                if type(arg) is not int:
+                    raise TypeError()
+                sectorList.append(arg)
+            self._sectorSelector.setAutoSectors(sectorList)
+            print self._sectorSelector.__repr__()
+
+
+
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/willmott/__init__.py b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/willmott/calc.py b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/calc.py
new file mode 100644
index 0000000..a8e94ba
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/calc.py	
@@ -0,0 +1,292 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi, asin, acos, atan2, sin, cos, sqrt
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.log import logging
+from diffcalc.util import bound, AbstractPosition, DiffcalcException,\
+    x_rotation, z_rotation
+from diffcalc.hkl.vlieg.geometry import VliegGeometry
+from diffcalc.ub.calc import PaperSpecificUbCalcStrategy
+from diffcalc.hkl.calcbase import HklCalculatorBase
+from diffcalc.hkl.common import DummyParameterManager
+
+logger = logging.getLogger("diffcalc.hkl.willmot.calcwill")
+
+CHOOSE_POSITIVE_GAMMA = True
+
+TORAD = pi / 180
+TODEG = 180 / pi
+I = matrix('1 0 0; 0 1 0; 0 0 1')
+SMALL = 1e-10
+
+TEMPORARY_CONSTRAINTS_DICT_RAD = {'betain': 2 * TORAD}
+
+
+def create_matrices(delta, gamma, omegah, phi):
+    return (calc_DELTA(delta), calc_GAMMA(gamma), calc_OMEGAH(omegah),
+            calc_PHI(phi))
+
+
+def calc_DELTA(delta):
+    return x_rotation(delta)                                             # (39)
+
+
+def calc_GAMMA(gamma):
+    return z_rotation(gamma)                                             # (40)
+
+
+def calc_OMEGAH(omegah):
+    return x_rotation(omegah)                                            # (41)
+
+
+def calc_PHI(phi):
+    return z_rotation(phi)                                               # (42)
+
+
+def angles_to_hkl_phi(delta, gamma, omegah, phi):
+    """Calculate hkl matrix in phi frame in units of 2*pi/lambda
+    """
+    DELTA, GAMMA, OMEGAH, PHI = create_matrices(delta, gamma, omegah, phi)
+    H_lab = (GAMMA * DELTA - I) * matrix([[0], [1], [0]])                # (43)
+    H_phi = PHI.I * OMEGAH.I * H_lab                                     # (44)
+    return H_phi
+
+
+def angles_to_hkl(delta, gamma, omegah, phi, wavelength, UB):
+    """Calculate hkl matrix in reprical lattice space in units of 1/Angstrom
+    """
+    H_phi = angles_to_hkl_phi(delta, gamma, omegah, phi) * 2 * pi / wavelength
+    hkl = UB.I * H_phi                                                    # (5)
+    return hkl
+
+
+class WillmottHorizontalPosition(AbstractPosition):
+
+    def __init__(self, delta=None, gamma=None, omegah=None, phi=None):
+        self.delta = delta
+        self.gamma = gamma
+        self.omegah = omegah
+        self.phi = phi
+
+    def clone(self):
+        return WillmottHorizontalPosition(self.delta, self.gamma, self.omegah,
+                                          self.phi)
+
+    def changeToRadians(self):
+        self.delta *= TORAD
+        self.gamma *= TORAD
+        self.omegah *= TORAD
+        self.phi *= TORAD
+
+    def changeToDegrees(self):
+        self.delta *= TODEG
+        self.gamma *= TODEG
+        self.omegah *= TODEG
+        self.phi *= TODEG
+
+    def totuple(self):
+        return (self.delta, self.gamma, self.omegah, self.phi)
+
+    def __str__(self):
+        return ('WillmottHorizontalPosition('
+                'delta: %.4f gamma: %.4f omegah: %.4f phi: %.4f)' %
+                (self.delta, self.gamma, self.omegah, self.phi))
+
+
+class WillmottHorizontalGeometry(object):
+
+    def __init__(self):
+        self.name = 'willmott_horizontal'
+
+    def physical_angles_to_internal_position(self, physicalAngles):
+        return WillmottHorizontalPosition(*physicalAngles)
+
+    def internal_position_to_physical_angles(self, internalPosition):
+        return internalPosition.totuple()
+
+    def create_position(self, delta, gamma, omegah, phi):
+        return WillmottHorizontalPosition(delta, gamma, omegah, phi)
+
+
+class WillmottHorizontalUbCalcStrategy(PaperSpecificUbCalcStrategy):
+
+    def calculate_q_phi(self, pos):
+        H_phi = angles_to_hkl_phi(*pos.totuple())
+        return matrix(H_phi.tolist())
+
+
+class DummyConstraints(object):
+
+    @property
+    def reference(self):
+        """dictionary of constrained reference circles"""
+        return TEMPORARY_CONSTRAINTS_DICT_RAD
+
+
+class ConstraintAdapter(object):
+
+    def __init__(self, constraints):
+        self._constraints = constraints
+
+    def getParameterDict(self):
+        names = self._constraints.available
+        return dict(zip(names, [None] * len(names)))
+
+    def setParameter(self, name, value):
+        self._constraints.set_constraint(name, value)
+
+    def get(self, name):
+        if name in self._constraints.all:
+            val = self._constraints.get_value(name)
+            return 999 if val is None else val
+        else:
+            return 999
+
+    def update_tracked(self):
+        pass
+
+
+class WillmottHorizontalCalculator(HklCalculatorBase):
+
+    def __init__(self, ubcalc, geometry, hardware, constraints,
+                 raiseExceptionsIfAnglesDoNotMapBackToHkl=True):
+        """"
+        Where constraints.reference is a one element dict with the key either
+        ('betain', 'betaout' or 'equal') and the value a number or None for
+        'betain_eq_betaout'
+        """
+
+        HklCalculatorBase.__init__(self, ubcalc, geometry, hardware,
+                                   raiseExceptionsIfAnglesDoNotMapBackToHkl)
+
+        if constraints is not None:
+            self.constraints = constraints
+            self.parameter_manager = ConstraintAdapter(constraints)
+        else:
+            self.constraints = DummyConstraints()
+            self.parameter_manager = DummyParameterManager()
+
+    @property
+    def _UB(self):
+        return self._ubcalc.UB
+
+    def _anglesToHkl(self, pos, wavelength):
+        """
+        Calculate miller indices from position in radians.
+        """
+        hkl_matrix = angles_to_hkl(pos.delta, pos.gamma, pos.omegah, pos.phi,
+                             wavelength, self._UB)
+        return hkl_matrix[0, 0], hkl_matrix[1, 0], hkl_matrix[2, 0],
+
+    def _anglesToVirtualAngles(self, pos, wavelength):
+        """
+        Calculate virtual-angles in radians from position in radians.
+
+        Return theta, alpha, and beta in a dictionary.
+        """
+
+        betain = pos.omegah                                              # (52)
+
+        hkl = angles_to_hkl(pos.delta, pos.gamma, pos.omegah, pos.phi,
+                              wavelength, self._UB)
+        H_phi = self._UB * hkl
+        H_phi = H_phi / (2 * pi / wavelength)
+        l_phi = H_phi[2, 0]
+        sin_betaout = l_phi - sin(betain)
+        betaout = asin(bound(sin_betaout))                               # (54)
+
+        cos_2theta = cos(pos.delta) * cos(pos.gamma)
+        theta = acos(bound(cos_2theta)) / 2.
+
+        return {'theta': theta, 'betain': betain, 'betaout': betaout}
+
+    def _hklToAngles(self, h, k, l, wavelength):
+        """
+        Calculate position and virtual angles in radians for a given hkl.
+        """
+
+        H_phi = self._UB * matrix([[h], [k], [l]])  # units: 1/Angstrom
+        H_phi = H_phi / (2 * pi / wavelength)       # units: 2*pi/wavelength
+        h_phi = H_phi[0, 0]
+        k_phi = H_phi[1, 0]
+        l_phi = H_phi[2, 0]                                               # (5)
+
+        ### determine betain (omegah) and betaout ###
+
+        if not self.constraints.reference:
+            raise ValueError("No reference constraint has been constrained.")
+
+        ref_name, ref_value = self.constraints.reference.items()[0]
+        if ref_value is not None:
+            ref_value *= TORAD
+        if ref_name == 'betain':
+            betain = ref_value
+            betaout = asin(bound(l_phi - sin(betain)))                   # (53)
+        elif ref_name == 'betaout':
+            betaout = ref_value
+            betain = asin(bound(l_phi - sin(betaout)))                   # (54)
+        elif ref_name == 'bin_eq_bout':
+            betain = betaout = asin(bound(l_phi / 2))                    # (55)
+        else:
+            raise ValueError("Unexpected constraint name'%s'." % ref_name)
+
+        if abs(betain) < SMALL:
+            raise DiffcalcException('required betain was 0 degrees (requested '
+                                    'q is perpendicular to surface normal)')
+        if betain < -SMALL:
+            raise DiffcalcException("betain was -ve (%.4f)" % betain)
+#        logger.info('betain = %.4f, betaout = %.4f',
+#                    betain * TODEG, betaout * TODEG)
+        omegah = betain                                                  # (52)
+
+        ### determine H_lab (X, Y and Z) ###
+
+        Y = -(h_phi ** 2 + k_phi ** 2 + l_phi ** 2) / 2                  # (45)
+
+        Z = (sin(betaout) + sin(betain) * (Y + 1)) / cos(omegah)         # (47)
+
+        X_squared = (h_phi ** 2 + k_phi ** 2 -
+                    ((cos(betain) * Y + sin(betain) * Z) ** 2))          # (48)
+        if (X_squared < 0) and (abs(X_squared) < SMALL):
+            X_squared = 0
+        Xpositive = sqrt(X_squared)
+        if CHOOSE_POSITIVE_GAMMA:
+            X = -Xpositive
+        else:
+            X = Xpositive
+#        logger.info('H_lab (X,Y,Z) = [%.4f, %.4f, %.4f]', X, Y, Z)
+        ### determine diffractometer angles ###
+
+        gamma = atan2(-X, Y + 1)                                         # (49)
+        if (abs(gamma) < SMALL):
+            # degenerate case, only occurs when q || z
+            delta = 2 * omegah
+        else:
+            delta = atan2(Z * sin(gamma), -X)                            # (50)
+        M = cos(betain) * Y + sin(betain) * Z
+        phi = atan2(h_phi * M - k_phi * X, h_phi * X + k_phi * M)        # (51)
+
+        pos = WillmottHorizontalPosition(delta, gamma, omegah, phi)
+        virtual_angles = {'betain': betain, 'betaout': betaout}
+        return pos, virtual_angles
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/willmott/commands.py b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/commands.py
new file mode 100644
index 0000000..1d6cadd
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/commands.py	
@@ -0,0 +1,58 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc.hkl.common import getNameFromScannableOrString
+from diffcalc.util import command
+
+
+class WillmottHklCommands(object):
+
+    def __init__(self, hklcalc):
+        self._hklcalc = hklcalc
+        self.commands = [self.con,
+                         self.uncon,
+                         self.cons]
+
+    def __str__(self):
+        return self._hklcalc.__str__()
+
+    @command
+    def con(self, scn_or_string):
+        """con <constraint> -- constrains constraint
+        """
+        name = getNameFromScannableOrString(scn_or_string)
+        self._hklcalc.constraints.constrain(name)
+        print self._report_constraints()
+
+    @command
+    def uncon(self, scn_or_string):
+        """uncon <constraint> -- unconstrains constraint
+        """
+        name = getNameFromScannableOrString(scn_or_string)
+        self._hklcalc.constraints.unconstrain(name)
+        print self._report_constraints()
+
+    @command
+    def cons(self):
+        """cons -- list available constraints and values
+        """
+        print self._report_constraints()
+
+    def _report_constraints(self):
+        return (self._hklcalc.constraints.build_display_table_lines() + '\n\n' +
+               self._hklcalc.constraints._report_constraints())
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/willmott/constraints.py b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/constraints.py
new file mode 100644
index 0000000..9ab5abd
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/willmott/constraints.py	
@@ -0,0 +1,156 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc.util import DiffcalcException
+
+
+def filter_dict(d, keys):
+    """Return a copy of d containing only keys that are in keys"""
+    ##return {k: d[k] for k in keys} # requires Python 2.6
+    return dict((k, d[k]) for k in keys if k in d.keys())
+
+
+ref_constraints = ('betain', 'betaout', 'bin_eq_bout')
+valueless_constraints = ('bin_eq_bout')
+all_constraints = ref_constraints
+
+
+class WillmottConstraintManager(object):
+    """Constraints in degrees.
+    """
+
+    def __init__(self):
+        self._constrained = {'bin_eq_bout': None}
+
+    @property
+    def available_constraint_names(self):
+        """list of all available constraints"""
+        return all_constraints
+
+    @property
+    def all(self):  # @ReservedAssignment
+        """dictionary of all constrained values"""
+        return self._constrained.copy()
+
+    @property
+    def reference(self):
+        """dictionary of constrained reference circles"""
+        return filter_dict(self.all, ref_constraints)
+
+    @property
+    def constrained_names(self):
+        """ordered tuple of constained circles"""
+        names = self.all.keys()
+        names.sort(key=lambda name: list(all_constraints).index(name))
+        return tuple(names)
+
+    def is_constrained(self, name):
+        return name in self._constrained
+
+    def get_value(self, name):
+        return self._constrained[name]
+
+    def _build_display_table(self):
+        constraint_types = (ref_constraints,)
+        num_rows = max([len(col) for col in constraint_types])
+        max_name_width = max(
+            [len(name) for name in sum(constraint_types[:2], ())])
+        # headings
+        lines = ['    ' + 'REF'.ljust(max_name_width)]
+        lines.append('    ' + '=' * max_name_width + ' ')
+
+        # constraint rows
+        for n_row in range(num_rows):
+            cells = []
+            for col in constraint_types:
+                name = col[n_row] if n_row < len(col) else ''
+                cells.append(self._label_constraint(name))
+                cells.append(('%-' + str(max_name_width) + 's ') % name)
+            lines.append(''.join(cells))
+        lines.append
+        return '\n'.join(lines)
+
+    def _report_constraints(self):
+        if not self.reference:
+            return "!!! No reference constraint set"
+        name, val = self.reference.items()[0]
+        if name in valueless_constraints:
+            return "    %s" % name
+        else:
+            if val is None:
+                return "!!! %s: ---" % name
+            else:
+                return "    %s: %.4f" % (name, val)
+
+    def _label_constraint(self, name):
+        if name == '':
+            label = '    '
+        elif (self.is_constrained(name) and (self.get_value(name) is None) and
+            name not in valueless_constraints):
+            label = 'o-> '
+        elif self.is_constrained(name):
+            label = '--> '
+        else:
+            label = '    '
+        return label
+
+    def constrain(self, name):
+        if name in self.all:
+            return "%s is already constrained." % name.capitalize()
+        elif name in ref_constraints:
+            return self._constrain_reference(name)
+        else:
+            raise DiffcalcException('%s is not a valid constraint name')
+
+    def _constrain_reference(self, name):
+        if self.reference:
+            constrained_name = self.reference.keys()[0]
+            del self._constrained[constrained_name]
+            self._constrained[name] = None
+            return '%s constraint replaced.' % constrained_name.capitalize()
+        else:
+            self._constrained[name] = None
+
+    def unconstrain(self, name):
+        if name in self._constrained:
+            del self._constrained[name]
+        else:
+            return "%s was not already constrained." % name.capitalize()
+
+###
+    def _check_constraint_settable(self, name, verb):
+        if name not in all_constraints:
+            raise DiffcalcException(
+                'Could not %(verb)s %(name)s as this is not an available '
+                'constraint.' % locals())
+        elif name not in self.all.keys():
+            raise DiffcalcException(
+                'Could not %(verb)s %(name)s as this is not currently '
+                'constrained.' % locals())
+        elif name in valueless_constraints:
+            raise DiffcalcException(
+                'Could not %(verb)s %(name)s as this constraint takes no '
+                'value.' % locals())
+
+    def set_constraint(self, name, value):  # @ReservedAssignment
+        self._check_constraint_settable(name, 'set')
+        old_value = self.all[name]
+        old = str(old_value) if old_value is not None else '---'
+        self._constrained[name] = float(value)
+        new = str(value)
+        return "%(name)s : %(old)s --> %(new)s" % locals()
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/you/__init__.py b/script/test/diffcalc (copy)/diffcalc/hkl/you/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/you/calc.py b/script/test/diffcalc (copy)/diffcalc/hkl/you/calc.py
new file mode 100644
index 0000000..1e9ac96
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/you/calc.py	
@@ -0,0 +1,1167 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi, sin, cos, acos, asin, atan2, sqrt
+from itertools import product
+
+try:
+    from numpy import matrix
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix
+    from numjy.linalg import norm
+
+from diffcalc.log import logging
+from diffcalc.hkl.calcbase import HklCalculatorBase
+from diffcalc.hkl.you.geometry import create_you_matrices, calcMU, calcPHI, \
+    calcCHI, calcETA
+from diffcalc.hkl.you.geometry import YouPosition
+from diffcalc.util import DiffcalcException, bound, angle_between_vectors,\
+    y_rotation
+from diffcalc.util import cross3, z_rotation, x_rotation
+from diffcalc.ub.calc import PaperSpecificUbCalcStrategy
+
+from diffcalc.hkl.you.constraints import NUNAME
+logger = logging.getLogger("diffcalc.hkl.you.calc")
+I = matrix('1 0 0; 0 1 0; 0 0 1')
+
+SMALL = 1e-6
+TORAD = pi / 180
+TODEG = 180 / pi
+
+PRINT_DEGENERATE = False
+PRINT_WARNINGS = False
+
+
+def is_small(x):
+    return abs(x) < SMALL
+
+
+def sign(x):
+    if is_small(x):
+        return 0
+    if x > 0:
+        return 1
+    # x < 0
+    return -1
+
+
+def normalised(vector):
+    return vector * (1 / norm(vector))
+
+
+def cut_at_minus_pi(value):
+    if value < (-pi - SMALL):
+        return value + 2 * pi
+    if value >= pi + SMALL:
+        return value - 2 * pi
+    return value
+
+
+def _calc_N(Q, n):
+    """Return N as described by Equation 31"""
+    Q = normalised(Q)
+    n = normalised(n)
+    if is_small(angle_between_vectors(Q, n)):
+        # Replace the reference vector with an alternative vector from Eq.(78) 
+        idx_min, _ = min(enumerate([abs(Q[0, 0]), abs(Q[1, 0]), abs(Q[2, 0])]), key=lambda v: v[1])
+        idx_1, idx_2 = [idx for idx in range(3) if idx != idx_min]
+        qval = sqrt(Q[idx_1, 0] * Q[idx_1, 0] + Q[idx_2, 0] * Q[idx_2, 0])
+        n[idx_min, 0] = qval
+        n[idx_1, 0] = -Q[idx_min, 0] * Q[idx_1, 0] / qval
+        n[idx_2, 0] = -Q[idx_min, 0] * Q[idx_2, 0] / qval
+        if is_small(norm(n)):
+            n[idx_min, 0] = 0
+            n[idx_1, 0] =  Q[idx_2, 0] / qval
+            n[idx_2, 0] = -Q[idx_1, 0] / qval
+    Qxn = cross3(Q, n)
+    QxnxQ = cross3(Qxn, Q)
+    QxnxQ = normalised(QxnxQ)
+    Qxn = normalised(Qxn)
+    return matrix([[Q[0, 0], QxnxQ[0, 0], Qxn[0, 0]],
+                   [Q[1, 0], QxnxQ[1, 0], Qxn[1, 0]],
+                   [Q[2, 0], QxnxQ[2, 0], Qxn[2, 0]]])
+
+
+def _calc_angle_between_naz_and_qaz(theta, alpha, tau):
+    # Equation 30:
+    top = cos(tau) - sin(alpha) * sin(theta)
+    bottom = cos(alpha) * cos(theta)
+    if is_small(bottom):
+        if is_small(cos(alpha)):
+            raise ValueError('cos(alpha) is too small')
+        if is_small(cos(theta)):
+            raise ValueError('cos(theta) is too small')
+    if is_small(sin(tau)):
+        return 0.
+    return acos(bound(top / bottom))
+
+
+def youAnglesToHkl(pos, wavelength, UBmatrix):
+    """Calculate miller indices from position in radians.
+    """
+
+    [MU, DELTA, NU, ETA, CHI, PHI] = create_you_matrices(*pos.totuple())
+
+    q_lab = (NU * DELTA - I) * matrix([[0], [2 * pi / wavelength], [0]])   # 12
+
+    hkl = UBmatrix.I * PHI.I * CHI.I * ETA.I * MU.I * q_lab
+
+    return hkl[0, 0], hkl[1, 0], hkl[2, 0]
+
+
+def _tidy_degenerate_solutions(pos, constraints):
+
+    original = pos.inDegrees()
+    detector_like_constraint = constraints.detector or constraints.naz
+    nu_constrained_to_0 = is_small(pos.nu) and detector_like_constraint
+    mu_constrained_to_0 = is_small(pos.mu) and 'mu' in constraints.sample
+    delta_constrained_to_0 = is_small(pos.delta) and detector_like_constraint
+    eta_constrained_to_0 = is_small(pos.eta) and 'eta' in constraints.sample
+    phi_not_constrained = not 'phi' in constraints.sample
+
+    if nu_constrained_to_0 and mu_constrained_to_0 and phi_not_constrained:
+        # constrained to vertical 4-circle like mode
+        if is_small(pos.chi):  # phi || eta
+            desired_eta = pos.delta / 2.
+            eta_diff = desired_eta - pos.eta
+            pos.eta = desired_eta
+            pos.phi -= eta_diff
+            if PRINT_DEGENERATE:
+                print ('DEGENERATE: with chi=0, phi and eta are colinear:'
+                       'choosing eta = delta/2 by adding % 7.3f to eta and '
+                       'removing it from phi. (mu=%s=0 only)' % (eta_diff * TODEG, NUNAME))
+                print '            original:', original
+
+    elif delta_constrained_to_0 and eta_constrained_to_0 and phi_not_constrained:
+        # constrained to horizontal 4-circle like mode
+        if is_small(pos.chi - pi / 2):  # phi || mu
+            desired_mu = pos.nu / 2.
+            mu_diff = desired_mu - pos.mu
+            pos.mu = desired_mu
+            pos.phi += mu_diff
+            if PRINT_DEGENERATE:
+                print ('DEGENERATE: with chi=90, phi and mu are colinear: choosing'
+                       ' mu = %s/2 by adding % 7.3f to mu and to phi. '
+                       '(delta=eta=0 only)' % (NUNAME, mu_diff * TODEG))
+                print '            original:', original
+
+    return pos
+
+
+def _theta_and_qaz_from_detector_angles(delta, nu):
+    # Equation 19:
+    cos_2theta = cos(delta) * cos(nu)
+    theta = acos(cos_2theta) / 2.
+    sgn = sign(sin(2. * theta))
+    qaz = atan2(sgn * sin(delta), sgn * cos(delta) * sin(nu))
+    return theta, qaz
+
+
+class YouUbCalcStrategy(PaperSpecificUbCalcStrategy):
+
+    def calculate_q_phi(self, pos):
+
+        [MU, DELTA, NU, ETA, CHI, PHI] = create_you_matrices(*pos.totuple())
+        # Equation 12: Compute the momentum transfer vector in the lab  frame
+        y = matrix('0; 1; 0')
+        q_lab = (NU * DELTA - I) * y
+        # Transform this into the phi frame.
+        return PHI.I * CHI.I * ETA.I * MU.I * q_lab
+
+
+UNREACHABLE_MSG = (
+    'The current combination of constraints with %s = %.4f\n'
+    'prohibits a solution for the specified reflection.')
+
+
+class YouHklCalculator(HklCalculatorBase):
+
+    def __init__(self, ubcalc, geometry, hardware, constraints,
+                  raiseExceptionsIfAnglesDoNotMapBackToHkl=True):
+        HklCalculatorBase.__init__(self, ubcalc, geometry, hardware,
+                                   raiseExceptionsIfAnglesDoNotMapBackToHkl)
+        self._hardware = hardware  # for checking limits only
+        self.constraints = constraints
+        self.parameter_manager = constraints  # TODO: remove need for this attr
+
+    def __str__(self):
+        return self.constraints.__str__()
+
+    def _get_n_phi(self):
+        return self._ubcalc.n_phi
+    
+    def _get_ubmatrix(self):
+        return self._getUBMatrix()  # for consistency
+
+    def repr_mode(self):
+        return repr(self.constraints.all)
+
+    def _anglesToHkl(self, pos, wavelength):
+        """Calculate miller indices from position in radians.
+        """
+        return youAnglesToHkl(pos, wavelength, self._get_ubmatrix())
+
+    def _anglesToVirtualAngles(self, pos, _wavelength):
+        """Calculate pseudo-angles in radians from position in radians.
+
+        Return theta, qaz, alpha, naz, tau, psi and beta in a dictionary.
+
+        """
+
+        # depends on surface normal n_lab.
+        mu, delta, nu, eta, chi, phi = pos.totuple()
+
+        theta, qaz = _theta_and_qaz_from_detector_angles(delta, nu)      # (19)
+
+        [MU, _, _, ETA, CHI, PHI] = create_you_matrices(mu,
+                                           delta, nu, eta, chi, phi)
+        Z = MU * ETA * CHI * PHI
+        n_lab = Z * self._get_n_phi()
+        alpha = asin(bound((-n_lab[1, 0])))
+        naz = atan2(n_lab[0, 0], n_lab[2, 0])                            # (20)
+
+        cos_tau = cos(alpha) * cos(theta) * cos(naz - qaz) + \
+                  sin(alpha) * sin(theta)
+        tau = acos(bound(cos_tau))                                       # (23)
+
+        # Compute Tau using the dot product directly (THIS ALSO WORKS)
+#        q_lab = ( (NU * DELTA - I ) * matrix([[0],[1],[0]])
+#        norm = norm(q_lab)
+#        q_lab = matrix([[1],[0],[0]]) if norm == 0 else q_lab * (1/norm)
+#        tau_from_dot_product = acos(bound(dot3(q_lab, n_lab)))
+
+        sin_beta = 2 * sin(theta) * cos(tau) - sin(alpha)
+        beta = asin(bound(sin_beta))                                     # (24)
+
+        psi = next(self._calc_psi(alpha, theta, tau, qaz, naz))
+
+        return {'theta': theta, 'qaz': qaz, 'alpha': alpha,
+                'naz': naz, 'tau': tau, 'psi': psi, 'beta': beta}
+
+
+    def _choose_single_solution(self, pos_virtual_angles_pairs_in_degrees):
+
+        if len(pos_virtual_angles_pairs_in_degrees) == 1:
+            return pos_virtual_angles_pairs_in_degrees[0]
+
+        absolute_distances = []
+        for pos_, _ in pos_virtual_angles_pairs_in_degrees:
+            absolute_distances.append(sum([abs(pos_.totuple()[i]) for i in (0, 3, 4, 5)]))
+
+        shortest_solution_index = absolute_distances.index(
+            min(absolute_distances))
+        pos, virtual_angles = pos_virtual_angles_pairs_in_degrees[shortest_solution_index]
+
+        if logger.isEnabledFor(logging.INFO):
+            msg = ('Multiple sample solutions found (choosing solution with '
+                   'shortest distance to all-zeros position):\n')
+            i = 0
+            for (pos_, _), distance in zip(pos_virtual_angles_pairs_in_degrees,
+                                          absolute_distances):
+                msg += '*' if i == shortest_solution_index else '.'
+
+                msg += ('mu=% 7.3f, delta=% 7.3f, nu=% 7.3f, eta=% 7.3f, chi=% 7.3f, phi=% 7.3f' %
+                        pos_.totuple())
+                msg += ' (distance=% 4.3f)\n' % (distance * TODEG)
+                i += 1
+            msg += ':\n'
+            logger.info(msg)
+
+        return pos, virtual_angles
+
+    def hklToAngles(self, h, k, l, wavelength, return_all_solutions=False):
+        """
+        Return verified Position and all virtual angles in degrees from
+        h, k & l and wavelength in Angstroms.
+
+        The calculated Position is verified by checking that it maps back using
+        anglesToHkl() to the requested hkl value.
+
+        Those virtual angles fixed or generated while calculating the position
+        are verified by by checking that they map back using
+        anglesToVirtualAngles to the virtual angles for the given position.
+
+        Throws a DiffcalcException if either check fails and
+        raiseExceptionsIfAnglesDoNotMapBackToHkl is True, otherwise displays a
+        warning.
+        """
+
+        pos_virtual_angles_pairs = self._hklToAngles(h, k, l, wavelength, return_all_solutions)  # in rad
+        assert pos_virtual_angles_pairs
+        pos_virtual_angles_pairs_in_degrees = []
+        for pos, virtual_angles in pos_virtual_angles_pairs:
+            
+            # to degrees:
+            pos.changeToDegrees()
+            for key, val in virtual_angles.items():
+                if val is not None:
+                    virtual_angles[key] = val * TODEG
+
+            self._verify_pos_map_to_hkl(h, k, l, wavelength, pos)
+
+            pos_virtual_angles_pairs_in_degrees.append((pos, virtual_angles))
+
+        if return_all_solutions:
+            return pos_virtual_angles_pairs_in_degrees
+        else:
+            pos, virtual_angles = self._choose_single_solution(pos_virtual_angles_pairs_in_degrees)
+            return pos, virtual_angles
+
+
+    def hkl_to_all_angles(self, h, k, l, wavelength):
+        return self.hklToAngles(h, k, l, wavelength, True)
+
+
+    def _hklToAngles(self, h, k, l, wavelength, return_all_solutions=False):
+        """(pos, virtualAngles) = hklToAngles(h, k, l, wavelength) --- with
+        Position object pos and the virtual angles returned in degrees. Some
+        modes may not calculate all virtual angles.
+        """
+
+        if not self.constraints.is_fully_constrained():
+            raise DiffcalcException(
+                "Diffcalc is not fully constrained.\n"
+                "Type 'help con' for instructions")
+
+        if not self.constraints.is_current_mode_implemented():
+            raise DiffcalcException(
+                "Sorry, the selected constraint combination is valid but "
+                "is not implemented. Type 'help con' for implemented combinations")
+              
+        # constraints are dictionaries  
+        ref_constraint = self.constraints.reference
+        if ref_constraint:
+            ref_constraint_name, ref_constraint_value = ref_constraint.items()[0]
+        det_constraint = self.constraints.detector
+        naz_constraint = self.constraints.naz
+        samp_constraints = self.constraints.sample
+            
+        assert not (det_constraint and naz_constraint), (
+               "Two 'detector' constraints given")
+
+
+        h_phi = self._get_ubmatrix() * matrix([[h], [k], [l]])
+        theta = self._calc_theta(h_phi, wavelength)
+        tau = angle_between_vectors(h_phi, self._get_n_phi())
+        
+        if is_small(sin(tau)) and ref_constraint:
+            if ref_constraint_name == 'psi':
+                raise DiffcalcException("Azimuthal angle 'psi' is undefined as reference and scattering vectors parallel.\n"
+                                        "Please constrain one of the sample angles or choose different reference vector orientation.")
+            elif ref_constraint_name == 'a_eq_b':
+                raise DiffcalcException("Reference constraint 'a_eq_b' is redundant as reference and scattering vectors are parallel.\n"
+                                        "Please constrain one of the sample angles or choose different reference vector orientation.")
+
+        ### Reference constraint column ###
+
+        if ref_constraint:
+            # An angle for the reference vector (n) is given      (Section 5.2)         
+            alpha, _ = self._calc_remaining_reference_angles(
+                ref_constraint_name, ref_constraint_value, theta, tau)
+
+        solution_tuples = []
+        if det_constraint or naz_constraint:
+
+            if len(samp_constraints) == 1:
+                for qaz, naz, delta, nu in self._calc_det_angles_given_det_or_naz_constraint(
+                                                det_constraint, naz_constraint, theta, tau, alpha):
+                    for mu, eta, chi, phi in self._calc_sample_angles_from_one_sample_constraint(
+                                                samp_constraints, h_phi, theta, alpha, qaz, naz):
+                        solution_tuples.append((mu, delta, nu, eta, chi, phi))
+
+            elif len(samp_constraints) == 2:
+                if det_constraint:
+                    det_constraint_name, det_constraint_val = det_constraint.items()[0]
+                    for delta, nu, qaz in self._calc_remaining_detector_angles(det_constraint_name, det_constraint_val, theta):
+                        for mu, eta, chi, phi in self._calc_sample_angles_given_two_sample_and_detector(
+                            samp_constraints, qaz, theta, h_phi, self._get_n_phi()):
+                            solution_tuples.append((mu, delta, nu, eta, chi, phi))
+                
+                else:
+                    raise DiffcalcException(
+                        'No code yet to handle this combination of detector and sample constraints!')
+
+        elif len(samp_constraints) == 2:
+            if ref_constraint_name == 'psi':
+                psi_vals = [ref_constraint_value,]
+            else:
+                psi_vals = self._calc_psi(alpha, theta, tau)
+            for psi in psi_vals:
+                angles = list(self._calc_sample_given_two_sample_and_reference(
+                    samp_constraints, h_phi, theta, psi))
+                solution_tuples.extend(angles)
+
+        elif len(samp_constraints) == 3:
+            for angles in self._calc_angles_given_three_sample_constraints(
+                h, k, l, wavelength, return_all_solutions, samp_constraints,
+                 h_phi, theta):
+                solution_tuples.append(angles)
+        
+        if not solution_tuples:
+            raise DiffcalcException('No solutions were found. '
+                'Please consider using an alternative set of constraints.')
+
+        tidy_solutions = [_tidy_degenerate_solutions(YouPosition(*pos, unit='RAD'),
+                                                     self.constraints).totuple() for pos in solution_tuples]
+        merged_solution_tuples = set(self._filter_angle_limits(tidy_solutions,
+                                                               not return_all_solutions))
+        if not merged_solution_tuples:
+            raise DiffcalcException('No solutions were found matching existing hardware limits. '
+                'Please consider using an alternative set of constraints.')
+
+        #def _find_duplicate_angles(el):
+        #    idx, tpl = el
+        #    for tmp_tpl in filtered_solutions[idx:]:
+        #        if False not in [abs(x-y) < SMALL for x,y in zip(tmp_tpl, tpl)]:
+        #            return False
+        #    return True
+        #merged_solution_tuples = filter(_find_duplicate_angles, enumerate(filtered_solutions, 1))
+        position_pseudo_angles_pairs = self._create_position_pseudo_angles_pairs(wavelength, merged_solution_tuples)
+        if not position_pseudo_angles_pairs:
+            raise DiffcalcException('No solutions were found. Please check hardware limits and '
+                'consider using an alternative pseudo-angle constraints.')
+
+        return position_pseudo_angles_pairs
+
+
+    def _create_position_pseudo_angles_pairs(self, wavelength, merged_solution_tuples):
+
+        position_pseudo_angles_pairs = []
+        for pos in merged_solution_tuples:
+            # Create position
+            position = YouPosition(*pos, unit='RAD')
+            #position = _tidy_degenerate_solutions(position, self.constraints)
+            #if position.phi <= -pi + SMALL:
+            #    position.phi += 2 * pi
+            # pseudo angles calculated along the way were for the initial solution
+            # and may be invalid for the chosen solution TODO: anglesToHkl need no
+            # longer check the pseudo_angles as they will be generated with the
+            # same function and it will prove nothing
+            pseudo_angles = self._anglesToVirtualAngles(position, wavelength)
+            is_sol = True
+            for constraint in [self.constraints.reference,
+                               self.constraints.detector,
+                               self.constraints.naz]:
+                try:
+                    constraint_name, constraint_value = constraint.items()[0]
+                    if constraint_name == 'a_eq_b':
+                        if not is_small(pseudo_angles['alpha'] - pseudo_angles['beta']):
+                            is_sol = False
+                            break
+                    else:
+                        if not is_small(constraint_value - pseudo_angles[constraint_name]):
+                            is_sol = False
+                            break
+                except:
+                    continue
+            if is_sol:
+                position_pseudo_angles_pairs.append((position, pseudo_angles))
+        return position_pseudo_angles_pairs
+
+
+    def _calc_theta(self, h_phi, wavelength):
+        """Calculate theta using Equation1
+        """
+        q_length = norm(h_phi)
+        if is_small(q_length):
+            raise DiffcalcException('Reflection is unreachable as |Q| is too small')
+        wavevector = 2 * pi / wavelength
+        try:
+            theta = asin(bound(q_length / (2 * wavevector)))
+        except AssertionError:
+            raise DiffcalcException(
+                'Reflection is unreachable as |Q| is too long')
+        if is_small(cos(theta)):
+            raise DiffcalcException(
+                'Reflection is unreachable as theta angle is too close to 90 deg')
+        return theta
+
+    def _calc_psi(self, alpha, theta, tau, qaz=None, naz=None):
+        """Calculate psi from Eq. (18), (25) and (28)
+        """
+        sin_tau = sin(tau)
+        cos_theta = cos(theta)
+        if is_small(sin_tau):
+            # The reference vector is parallel to the scattering vector
+            yield float('nan')
+        elif is_small(cos_theta):
+            # Reflection is unreachable as theta angle is too close to 90 deg
+            yield float('nan')
+        elif is_small(sin(theta)):
+            # Reflection is unreachable as |Q| is too small
+            yield float('nan')
+        else:
+            cos_psi = ((cos(tau) * sin(theta) - sin(alpha)) / cos_theta) # (28)
+            if qaz is None or naz is None :
+                try:
+                    acos_psi = acos(bound(cos_psi / sin_tau))
+                    if is_small(acos_psi):
+                        yield 0.
+                    else:
+                        for psi in [acos_psi, -acos_psi]:
+                            yield psi
+                except AssertionError:
+                    if PRINT_WARNINGS:
+                        print ('WARNING: Diffcalc could not calculate an azimuth (psi)')
+                    yield float('nan')
+            else:
+                sin_psi = cos(alpha) * sin(qaz - naz)
+                sgn = sign(sin_tau)
+                eps = sin_psi**2 + cos_psi**2
+                sigma_ = eps/sin_tau**2 - 1
+                if not is_small(sigma_):
+                    if PRINT_WARNINGS:
+                        print ('WARNING: Diffcalc could not calculate a unique azimuth '
+                               '(psi) because of loss of accuracy in numerical calculation')
+                    yield float('nan')
+                else:
+                    psi = atan2(sgn * sin_psi, sgn * cos_psi)
+                    yield psi
+
+
+    def _calc_remaining_reference_angles(self, name, value, theta, tau):
+        """Return alpha and beta given one of a_eq_b, alpha, beta or psi
+        """
+        if name == 'psi':
+            psi = value
+            # Equation 26 for alpha
+            sin_alpha = (cos(tau) * sin(theta) -
+                         cos(theta) * sin(tau) * cos(psi))
+            if abs(sin_alpha) > 1 + SMALL:
+                raise DiffcalcException(UNREACHABLE_MSG % (name, value * TODEG))
+            alpha = asin(bound(sin_alpha))
+            # Equation 27 for beta
+            sin_beta = cos(tau) * sin(theta) + cos(theta) * sin(tau) * cos(psi)
+            if abs(sin_beta) > 1 + SMALL:
+                raise DiffcalcException(UNREACHABLE_MSG % (name, value * TODEG))
+
+            beta = asin(bound(sin_beta))
+
+        elif name == 'a_eq_b':
+            alpha = beta = asin(cos(tau) * sin(theta))            # (24)
+
+        elif name == 'alpha':
+            alpha = value                                                # (24)
+            sin_beta = 2 * sin(theta) * cos(tau) - sin(alpha)
+            if abs(sin_beta) > 1 + SMALL:
+                raise DiffcalcException(UNREACHABLE_MSG % (name, value * TODEG))
+            beta = asin(sin_beta)
+
+        elif name == 'beta':
+            beta = value
+            sin_alpha = 2 * sin(theta) * cos(tau) - sin(beta)            # (24)
+            if abs(sin_alpha) > 1 + SMALL:
+                raise DiffcalcException(UNREACHABLE_MSG % (name, value * TODEG))
+
+            alpha = asin(sin_alpha)
+
+        return alpha, beta
+
+    def _calc_det_angles_given_det_or_naz_constraint(
+            self, det_constraint, naz_constraint, theta, tau, alpha):
+        
+        assert det_constraint or naz_constraint
+        try:
+            naz_qaz_angle = _calc_angle_between_naz_and_qaz(theta, alpha, tau)
+        except AssertionError:
+            return
+        if det_constraint:
+            # One of the detector angles is given                 (Section 5.1)
+            det_constraint_name, det_constraint = det_constraint.items()[0]
+            for delta, nu, qaz in self._calc_remaining_detector_angles(
+                                        det_constraint_name, det_constraint, theta):
+                if is_small(naz_qaz_angle):
+                    naz_angles = [qaz,]
+                else:
+                    naz_angles = [qaz - naz_qaz_angle, qaz + naz_qaz_angle]
+                for naz in naz_angles:
+                    yield qaz, naz, delta, nu
+        elif naz_constraint: # The 'detector' angle naz is given:
+            det_constraint_name, det_constraint = naz_constraint.items()[0]
+            naz_name, naz = det_constraint_name, det_constraint
+            assert naz_name == 'naz'
+            if is_small(naz_qaz_angle):
+                qaz_angles = [naz,]
+            else:
+                qaz_angles = [naz - naz_qaz_angle, naz + naz_qaz_angle]
+            for qaz in qaz_angles:
+                for delta, nu, _ in self._calc_remaining_detector_angles(
+                                        'qaz', qaz, theta):
+                    yield qaz, naz, delta, nu
+
+    def _calc_remaining_detector_angles(self, constraint_name,
+                                        constraint_value, theta):
+        """Return delta, nu and qaz given one detector angle
+        """
+        #                                                         (section 5.1)
+        # Find qaz using various derivations of 17 and 18
+        sin_2theta = sin(2 * theta)
+        cos_2theta = cos(2 * theta)
+        if is_small(sin_2theta):
+            raise DiffcalcException(
+                'No meaningful scattering vector (Q) can be found when '
+                'theta is so small (%.4f).' % theta * TODEG)
+
+        if constraint_name == 'delta':
+            delta = constraint_value
+            try:
+                asin_qaz = asin(bound(sin(delta) / sin_2theta))              # (17 & 18)
+            except AssertionError:
+                return
+            cos_delta = cos(delta)
+            if is_small(cos_delta):
+                #raise DiffcalcException(
+                #    'The %s and %s circles are redundant when delta is constrained to %.0f degrees.'
+                #    'Please change delta constraint or use 4-circle mode.' % (NUNAME, 'mu', delta * TODEG))
+                if PRINT_DEGENERATE:
+                    print (('DEGENERATE: with delta=90, %s is degenerate: choosing '
+                           '%s = 0 (allowed because %s is unconstrained)') %
+                           (NUNAME, NUNAME, NUNAME))
+                acos_nu = 1.
+            else:
+                try:
+                    acos_nu = acos(bound(cos_2theta / cos_delta))
+                except AssertionError:
+                    return
+            if is_small(cos(asin_qaz)):
+                qaz_angles = [sign(asin_qaz) * pi / 2.,]
+            else:
+                qaz_angles = [asin_qaz, pi - asin_qaz]
+            if is_small(acos_nu):
+                nu_angles = [0.,]
+            else:
+                nu_angles = [acos_nu, -acos_nu]
+            for qaz, nu in product(qaz_angles, nu_angles):
+                sgn_ref = sign(sin_2theta) * sign(cos(qaz))
+                sgn_ratio = sign(sin(nu)) * sign(cos_delta)
+                if sgn_ref == sgn_ratio:
+                    yield delta, nu, qaz
+
+        elif constraint_name == NUNAME:
+            nu = constraint_value
+            cos_nu = cos(nu)
+            if is_small(cos_nu):
+                raise DiffcalcException(
+                    'The %s circle constraint to %.0f degrees is redundant.'
+                    'Please change this constraint or use 4-circle mode.' % (NUNAME, nu * TODEG))
+            cos_delta = cos_2theta / cos(nu)
+            cos_qaz = cos_delta * sin(nu) / sin_2theta
+            try:
+                acos_delta = acos(bound(cos_delta))
+                acos_qaz = acos(bound(cos_qaz))
+            except AssertionError:
+                return
+            if is_small(acos_qaz):
+                qaz_angles = [0.,]
+            else:
+                qaz_angles = [acos_qaz, -acos_qaz]
+            if is_small(acos_delta):
+                delta_angles = [0.,]
+            else:
+                delta_angles = [acos_delta, -acos_delta]
+            for qaz, delta in product(qaz_angles, delta_angles):
+                sgn_ref = sign(sin(delta))
+                sgn_ratio = sign(sin(qaz)) * sign(sin_2theta)
+                if sgn_ref == sgn_ratio:
+                    yield delta, nu, qaz
+
+        elif constraint_name == 'qaz':
+            qaz = constraint_value
+            asin_delta = asin(sin(qaz) * sin_2theta)
+            if is_small(cos(asin_delta)):
+                delta_angles = [sign(asin_delta) * pi / 2.,]
+            else:
+                delta_angles = [asin_delta, pi - asin_delta]
+            for delta in delta_angles:
+                cos_delta = cos(delta)
+                if is_small(cos_delta):
+                    if PRINT_DEGENERATE:
+                        print (('DEGENERATE: with delta=90, %s is degenerate: choosing '
+                               '%s = 0 (allowed because %s is unconstrained)') %
+                               (NUNAME, NUNAME, NUNAME))
+                    #raise DiffcalcException(
+                    #    'The %s circle is redundant when delta is at %.0f degrees.'
+                    #    'Please change detector constraint or use 4-circle mode.' % (NUNAME, delta * TODEG))
+                    nu = 0.
+                else:
+                    sgn_delta = sign(cos_delta)
+                    nu = atan2(sgn_delta * sin_2theta * cos(qaz), sgn_delta * cos_2theta)
+                yield delta, nu, qaz
+        else:
+            raise DiffcalcException(
+                constraint_name + ' is not an explicit detector angle '
+                '(naz cannot be handled here)')
+
+
+    def _calc_sample_angles_from_one_sample_constraint(
+            self, samp_constraints, h_phi, theta, alpha, qaz, naz):
+        
+        sample_constraint_name, sample_value = samp_constraints.items()[0]
+        q_lab = matrix([[cos(theta) * sin(qaz)], 
+                [-sin(theta)], 
+                [cos(theta) * cos(qaz)]]) # (18)
+        n_lab = matrix([[cos(alpha) * sin(naz)], 
+                [-sin(alpha)], 
+                [cos(alpha) * cos(naz)]]) # (20)
+        mu_eta_chi_phi_tuples = list(self._calc_remaining_sample_angles(
+            sample_constraint_name, sample_value, q_lab, n_lab, h_phi, 
+            self._get_n_phi()))
+        return mu_eta_chi_phi_tuples
+
+    def _calc_sample_given_two_sample_and_reference(
+            self, samp_constraints, h_phi, theta, psi):
+        
+        for angles in self._calc_sample_angles_given_two_sample_and_reference(
+                 samp_constraints, psi, theta, h_phi, self._get_n_phi()):
+            qaz, psi, mu, eta, chi, phi = angles 
+            values_in_deg = tuple(v * TODEG for v in angles)
+            logger.info('Initial angles: xi=%.3f, psi=%.3f, mu=%.3f, '
+                'eta=%.3f, chi=%.3f, phi=%.3f' % 
+                values_in_deg) # Try to find a solution for each possible transformed xi
+
+            logger.info("")
+            msg = "---Trying psi=%.3f, qaz=%.3f" % (psi * TODEG, qaz * TODEG)
+            logger.info(msg)
+            
+            for delta, nu, _ in self._calc_remaining_detector_angles('qaz', qaz, theta):
+                logger.info("delta=%.3f, %s=%.3f", delta * TODEG, NUNAME, nu * TODEG)
+                #for mu, eta, chi, phi in self._generate_sample_solutions(
+                #    mu, eta, chi, phi, samp_constraints.keys(), delta, 
+                #    nu, wavelength, (h, k, l), ref_constraint_name, 
+                #    ref_constraint_value):
+                yield mu, delta, nu, eta, chi, phi
+
+    def _calc_remaining_sample_angles(self, constraint_name, constraint_value,
+                                      q_lab, n_lab, q_phi, n_phi):
+        """Return phi, chi, eta and mu, given one of these"""
+        #                                                         (section 5.3)
+
+        N_lab = _calc_N(q_lab, n_lab)
+        N_phi = _calc_N(q_phi, n_phi)
+        Z = N_lab * N_phi.T
+
+        if constraint_name == 'mu':                                      # (35)
+            mu = constraint_value
+            V = calcMU(mu).I * N_lab * N_phi.T
+            try:
+                acos_chi = acos(bound(V[2, 2]))
+            except AssertionError:
+                return
+            if is_small(sin(acos_chi)):
+                # chi ~= 0 or 180 and therefor phi || eta The solutions for phi
+                # and eta here will be valid but will be chosen unpredictably.
+                # Choose eta=0:
+                #
+                # tan(phi+eta)=v12/v11 from docs/extensions_to_yous_paper.wxm
+                chi = acos_chi
+                eta = 0.
+                phi = atan2(-V[1, 0], V[1, 1])
+                logger.debug(
+                    'Eta and phi cannot be chosen uniquely with chi so close '
+                    'to 0 or 180. Returning phi=%.3f and eta=%.3f', 
+                    phi * TODEG, eta * TODEG)
+                yield mu, eta, chi, phi
+            else:
+                for chi in [acos_chi, -acos_chi]:
+                    sgn = sign(sin(chi))
+                    phi = atan2(-sgn * V[2, 1], -sgn * V[2, 0])
+                    eta = atan2(-sgn * V[1, 2],  sgn * V[0, 2])
+                    yield mu, eta, chi, phi
+
+        elif constraint_name == 'phi':                                     # (37)
+            phi = constraint_value
+            V = N_lab * N_phi.I * calcPHI(phi).T
+            try:
+                asin_eta = asin(bound(V[0, 1]))
+            except AssertionError:
+                return
+            if is_small(cos(asin_eta)):
+                raise DiffcalcException('Chi and mu cannot be chosen uniquely '
+                                        'with eta so close to +/-90.')
+            for eta in [asin_eta, pi - asin_eta]:
+                sgn = sign(cos(eta))
+                mu = atan2(sgn * V[2, 1], sgn * V[1, 1])
+                chi = atan2(sgn * V[0, 2], sgn * V[0, 0])
+                yield mu, eta, chi, phi
+
+        elif constraint_name in ('eta', 'chi'):
+            if constraint_name == 'eta':                                 # (39)
+                eta = constraint_value
+                cos_eta = cos(eta)
+                if is_small(cos_eta):
+                    #TODO: Not likely to happen in real world!?
+                    raise DiffcalcException(
+                        'Chi and mu cannot be chosen uniquely with eta '
+                        'constrained so close to +-90.')
+                try:
+                    asin_chi = asin(bound(Z[0, 2] / cos_eta))
+                except AssertionError:
+                    return
+                all_eta = [eta,]
+                all_chi = [asin_chi, pi - asin_chi]
+
+            else:  # constraint_name == 'chi'                            # (40)
+                chi = constraint_value
+                sin_chi = sin(chi)
+                if is_small(sin_chi):
+                    raise DiffcalcException(
+                        'Eta and phi cannot be chosen uniquely with chi '
+                        'constrained so close to 0. (Please contact developer '
+                        'if this case is useful for you)')
+                try:
+                    acos_eta = acos(bound(Z[0, 2] / sin_chi))
+                except AssertionError:
+                    return
+                all_eta = [acos_eta, -acos_eta]
+                all_chi = [chi,]
+
+            for chi, eta in product(all_chi, all_eta):
+                top_for_mu = Z[2, 2] * sin(eta) * sin(chi) + Z[1, 2] * cos(chi)
+                bot_for_mu = -Z[2, 2] * cos(chi) + Z[1, 2] * sin(eta) * sin(chi)
+                if is_small(top_for_mu) and is_small(bot_for_mu):
+                    # chi == +-90, eta == 0/180 and therefore phi || mu cos(chi) ==
+                    # 0 and sin(eta) == 0 Experience shows that even though e.g.
+                    # the z[2, 2] and z[1, 2] values used to calculate mu may be
+                    # basically 0 (1e-34) their ratio in every case tested so far
+                    # still remains valid and using them will result in a phi
+                    # solution that is continuous with neighbouring positions.
+                    #
+                    # We cannot test phi minus mu here unfortunately as the final
+                    # phi and mu solutions have not yet been chosen (they may be
+                    # +-x or 180+-x). Otherwise we could choose a sensible solution
+                    # here if the one found was incorrect.
+
+                    # tan(phi+eta)=v12/v11 from extensions_to_yous_paper.wxm
+                    phi_minus_mu = -atan2(Z[2, 0], Z[1, 1])
+                    logger.debug(
+                        'Mu and phi cannot be chosen uniquely with chi so close '
+                        'to +/-90 and eta so close 0 or 180.\n After the final '
+                        'solution has been chose phi-mu should equal: %.3f',
+                        phi_minus_mu * TODEG)
+                mu = atan2(-top_for_mu, -bot_for_mu)                         # (41)
+
+                top_for_phi = Z[0, 1] * cos(eta) * cos(chi) - Z[0, 0] * sin(eta)
+                bot_for_phi = Z[0, 1] * sin(eta) + Z[0, 0] * cos(eta) * cos(chi)
+                phi = atan2(top_for_phi, bot_for_phi)                        # (42)
+    #            if is_small(bot_for_phi) and is_small(top_for_phi):
+    #                raise DiffcalcException(
+    #                    'phi=%.3f cannot be known with confidence as top and '
+    #                    'bottom are both close to zero. chi=%.3f, eta=%.3f'
+    #                    % (mu * TODEG, chi * TODEG, eta * TODEG))
+                yield mu, eta, chi, phi
+
+        else:
+            raise DiffcalcException('Given angle must be one of phi, chi, eta or mu')
+
+    def _calc_angles_given_three_sample_constraints(
+            self, h, k, l, wavelength, return_all_solutions, samp_constraints,
+            h_phi, theta):
+        
+        if not 'mu' in samp_constraints:
+            eta_ = self.constraints.sample['eta']
+            chi_ = self.constraints.sample['chi']
+            phi_ = self.constraints.sample['phi']
+            try:
+                two_mu_qaz_pairs = _mu_and_qaz_from_eta_chi_phi(eta_, chi_, phi_, theta, h_phi)
+            except AssertionError:
+                return
+        else:
+            raise DiffcalcException(
+                'No code yet to handle this combination of 3 sample constraints!')
+    # TODO: Code duplicated above
+        for mu_, qaz in two_mu_qaz_pairs:
+            logger.debug("--- Trying mu_:%.f qaz_%.f", mu_ * TODEG, qaz * TODEG)
+            for delta, nu, _ in self._calc_remaining_detector_angles('qaz', qaz, theta):
+                logger.info("delta=%.3f, %s=%.3f", delta * TODEG, NUNAME, nu * TODEG)
+                yield mu_, delta, nu, eta_, chi_, phi_
+
+    def _calc_sample_angles_given_two_sample_and_reference(
+            self, samp_constraints, psi, theta, q_phi, n_phi):
+        """Available combinations:
+        chi, phi, reference
+        mu, eta, reference,
+        chi, eta, reference
+        chi, mu, reference
+        """
+
+        def __get_phi_and_qaz(chi, eta, mu):
+            a = sin(chi) * cos(eta)
+            b = sin(chi) * sin(eta) * sin(mu) - cos(chi) * cos(mu)
+            #atan2_xi = atan2(V[2, 2] * a + V[2, 0] * b,
+            #           V[2, 0] * a - V[2, 2] * b)                        # (54)
+            qaz = atan2(V[2, 0] * a - V[2, 2] * b,
+                       -V[2, 2] * a - V[2, 0] * b)                        # (54)
+    
+            a = sin(chi) * sin(mu) - cos(mu) * cos(chi) * sin(eta)
+            b = cos(mu) * cos(eta)
+            phi = atan2(V[1, 1] * a - V[0, 1] * b,
+                        V[0, 1] * a + V[1, 1] * b)                       # (55)
+    #        if is_small(mu+pi/2) and is_small(eta) and False:
+    #            phi_general = phi
+    #            # solved in extensions_to_yous_paper.wxm
+    #            phi = atan2(V[1, 1], V[0, 1])
+    #            logger.info("phi = %.3f or %.3f (std)",
+    #                        phi*TODEG, phi_general*TODEG )
+    
+            return qaz, phi
+
+        N_phi = _calc_N(q_phi, n_phi)
+        THETA = z_rotation(-theta)
+        PSI = x_rotation(psi)
+
+        if 'chi' in samp_constraints and 'phi' in samp_constraints:
+
+            chi = samp_constraints['chi']
+            phi = samp_constraints['phi']
+
+            CHI = calcCHI(chi)
+            PHI = calcPHI(phi)
+            V = CHI * PHI * N_phi * PSI.T * THETA.T                     # (46)
+
+            #atan2_xi = atan2(-V[2, 0], V[2, 2])
+            #atan2_eta = atan2(-V[0, 1], V[1, 1])
+            #atan2_mu = atan2(-V[2, 1], sqrt(V[2, 2] ** 2 + V[2, 0] ** 2))
+            try:
+                asin_mu = asin(bound(-V[2, 1]))
+            except AssertionError:
+                return
+            for mu in [asin_mu, pi - asin_mu]:
+                sgn_cosmu = sign(cos(mu))
+                #xi = atan2(-sgn_cosmu * V[2, 0], sgn_cosmu * V[2, 2])
+                qaz = atan2(sgn_cosmu * V[2, 2], sgn_cosmu * V[2, 0], )
+                eta = atan2(-sgn_cosmu * V[0, 1], sgn_cosmu * V[1, 1])
+                yield qaz, psi, mu, eta, chi, phi
+
+        elif 'mu' in samp_constraints and 'eta' in samp_constraints:
+
+            mu = samp_constraints['mu']
+            eta = samp_constraints['eta']
+
+            V = N_phi * PSI.T * THETA.T                                  # (49)
+            try:
+                bot = bound(-V[2, 1] / sqrt(sin(eta) ** 2 * cos(mu) ** 2 + sin(mu) ** 2))
+            except AssertionError:
+                return
+            if is_small(cos(mu) * sin(eta)):
+                eps = atan2(sin(eta) * cos(mu), sin(mu))
+                chi_vals = [eps + acos(bot), eps - acos(bot)]
+            else:
+                eps = atan2(sin(mu), sin(eta) * cos(mu))
+                chi_vals = [asin(bot) - eps, pi - asin(bot) - eps]       # (52)
+
+            ## Choose final chi solution here to obtain compatable xi and mu
+            ## TODO: This temporary solution works only for one case used on i07
+            ##       Return a list of possible solutions?
+            #if is_small(eta) and is_small(mu + pi / 2):
+            #    for chi in _generate_transformed_values(chi_orig):
+            #        if  pi / 2 <= chi < pi:
+            #            break
+            #else:
+            #    chi = chi_orig
+
+            for chi in chi_vals:
+                qaz, phi = __get_phi_and_qaz(chi, eta, mu)
+                yield qaz, psi, mu, eta, chi, phi
+
+        elif 'chi' in samp_constraints and 'eta' in samp_constraints:
+
+            chi = samp_constraints['chi']
+            eta = samp_constraints['eta']
+
+            V = N_phi * PSI.T * THETA.T                                  # (49)
+            try:
+                bot = bound(-V[2, 1] / sqrt(sin(eta) ** 2 * sin(chi) ** 2 + cos(chi) ** 2))
+            except AssertionError:
+                return
+            if is_small(cos(chi)):
+                eps = atan2(cos(chi), sin(chi) * sin(eta))
+                mu_vals = [eps + acos(bot), eps - acos(bot)]
+            else:
+                eps = atan2(sin(chi) * sin(eta), cos(chi))
+                mu_vals = [asin(bot) - eps, pi - asin(bot) - eps]       # (52)
+
+            for mu in mu_vals:
+                qaz, phi = __get_phi_and_qaz(chi, eta, mu)
+                yield qaz, psi, mu, eta, chi, phi
+
+        elif 'chi' in samp_constraints and 'mu' in samp_constraints:
+
+            chi = samp_constraints['chi']
+            mu = samp_constraints['mu']
+
+            V = N_phi * PSI.T * THETA.T                                  # (49)
+
+            try:
+                asin_eta = asin(bound((-V[2, 1] - cos(chi) * sin(mu)) / (sin(chi) * cos(mu))))
+            except AssertionError:
+                return
+
+            for eta in [asin_eta, pi - asin_eta]:
+                qaz, phi = __get_phi_and_qaz(chi, eta, mu)
+                yield qaz, psi, mu, eta, chi, phi
+
+        else:
+            raise DiffcalcException(
+                'No code yet to handle this combination of 2 sample '
+                'constraints and one reference!:' + str(samp_constraints))
+
+    def _calc_sample_angles_given_two_sample_and_detector(
+            self, samp_constraints, qaz, theta, q_phi, n_phi):
+        """Available combinations:
+        chi, phi, detector
+        mu, eta, detector
+        mu, phi, detector
+        """
+
+        N_phi = _calc_N(q_phi, n_phi)
+
+        if 'mu' in samp_constraints and 'eta' in samp_constraints:
+
+            mu = samp_constraints['mu']
+            eta = samp_constraints['eta']
+            
+            F = y_rotation(qaz - pi/2.)
+            THETA = z_rotation(-theta)
+            V = calcETA(eta).T * calcMU(mu).T * F * THETA                       # (56)
+
+            try:
+                bot = bound(-V[1, 0] / sqrt(N_phi[0, 0]**2 + N_phi[1, 0]**2))
+                eps = atan2(N_phi[1, 0], N_phi[0, 0])
+                phi_vals = [asin(bot) + eps, pi - asin(bot) + eps]              # (59)
+            except (AssertionError, ZeroDivisionError):
+                # For the case of (00l) reflection, where N_phi[0,0] = N_phi[1,0] = 0
+                chi = atan2(V[0, 0] * N_phi[2, 0], V[2, 0] * N_phi[2, 0])    # (57)
+                sgn_denom = sign(N_phi[1, 1] * N_phi[0, 2] - N_phi[1, 2] * N_phi[0, 1])
+                sin_phi = V[1, 1] * N_phi[1, 2] - V[1, 2] * N_phi[1, 1]
+                cos_phi = V[1, 1] * N_phi[0, 2] - V[1, 2] * N_phi[0, 1]
+                phi = atan2(sin_phi * sgn_denom, cos_phi * sgn_denom)
+                yield mu, eta, chi, phi
+                return
+            for phi in phi_vals:
+                a = N_phi[0, 0] * cos(phi) + N_phi[1, 0] * sin(phi)
+                chi = atan2(N_phi[2, 0] * V[0, 0] - a * V[2, 0],
+                            N_phi[2, 0] * V[2, 0] + a * V[0, 0])                # (60)
+                yield mu, eta, chi, phi
+
+        elif 'chi' in samp_constraints and 'phi' in samp_constraints:
+
+            chi = samp_constraints['chi']
+            phi = samp_constraints['phi']
+
+            CHI = calcCHI(chi)
+            PHI = calcPHI(phi)
+            V = CHI * PHI * N_phi                     # (62)
+
+            try:
+                bot = bound(V[2, 0] / sqrt(cos(qaz) ** 2 * cos(theta) ** 2 + sin(theta) ** 2))
+            except AssertionError:
+                return
+            eps = atan2(-cos(qaz) * cos(theta), sin(theta))
+            for mu in [asin(bot) + eps, pi - asin(bot) + eps]:
+                a = cos(theta) * sin(qaz)
+                b = -cos(theta) * sin(mu) * cos(qaz) + cos(mu) * sin(theta)
+                eta = atan2(V[1, 0] * a + V[0, 0] * b, V[0, 0] * a - V[1, 0]* b)
+                
+                #a = -cos(mu) * cos(qaz) * sin(theta) + sin(mu) * cos(theta)
+                #b = cos(mu) * sin(qaz)
+                #psi = atan2(-V[2, 2] * a - V[2, 1] * b, V[2, 1] * a - V[2, 2] * b)
+                yield mu, eta, chi, phi
+
+        elif 'mu' in samp_constraints and 'phi' in samp_constraints:
+
+            mu = samp_constraints['mu']
+            phi = samp_constraints['phi']
+
+            F = y_rotation(qaz - pi/2.)
+            THETA = z_rotation(-theta)
+            V = calcMU(mu).T * F * THETA
+            E = calcPHI(phi) * N_phi
+            
+            try:
+                bot = bound(-V[2, 0] / sqrt(E[0, 0]**2 + E[2, 0]**2))
+            except AssertionError:
+                return
+            eps = atan2(E[2, 0], E[0, 0])
+            for chi in [asin(bot) + eps, pi - asin(bot) + eps]:
+                a = E[0, 0] * cos(chi) + E[2, 0] * sin(chi)
+                eta = atan2(V[0, 0] * E[1, 0] - V[1, 0] * a, V[0, 0] * a + V[1, 0] * E[1, 0])
+                yield mu, eta, chi, phi
+        else:
+            raise DiffcalcException(
+                'No code yet to handle this combination of 2 sample '
+                'constraints and one detector!:' + str(samp_constraints))
+
+    def _filter_angle_limits(self, possible_solutions, filter_out_of_limits=True):
+        res = []
+        angle_names = self._hardware.get_axes_names()
+        for possible_solution in possible_solutions:
+            hw_sol = []
+            hw_possible_solution = self._geometry.internal_position_to_physical_angles(YouPosition(*possible_solution, unit='RAD'))
+            for name, value in zip(angle_names, hw_possible_solution):
+                hw_sol.append(self._hardware.cut_angle(name, value))
+            if filter_out_of_limits:
+                is_in_limits = all([self._hardware.is_axis_value_within_limits(name, value) for name, value in zip(angle_names, hw_sol)])
+            else:
+                is_in_limits = True
+            if is_in_limits:
+                sol = self._geometry.physical_angles_to_internal_position(tuple(hw_sol))
+                sol.changeToRadians()
+                res.append(sol.totuple())
+        return res
+
+def _mu_and_qaz_from_eta_chi_phi(eta, chi, phi, theta, h_phi):
+    
+    h_phi_norm = normalised(h_phi)                                    # (68,69) 
+    h1, h2, h3 = h_phi_norm[0, 0], h_phi_norm[1, 0], h_phi_norm[2, 0]
+    a = sin(chi) * h2 * sin(phi) + sin(chi) * h1 * cos(phi) - cos(chi) * h3
+    b = (- cos(chi) * sin(eta) * h2 * sin(phi)
+         - cos(eta) * h1 * sin(phi) + cos(eta) * h2 * cos(phi)
+         - cos(chi) * sin(eta) * h1 * cos(phi)
+         - sin(chi) * sin(eta) * h3)
+    c = -sin(theta)
+    sin_bit = bound(c / sqrt(a * a + b * b))
+    mu1 = asin(sin_bit) - atan2(b, a)
+    mu2 = pi - asin(sin_bit) - atan2(b, a)
+
+    mu1 = cut_at_minus_pi(mu1)
+    mu2 = cut_at_minus_pi(mu2)
+    
+    # TODO: This special case should be *removed* when the general case has shown
+    # to encompass it. It exists as fallback for a particular i16 experiment in
+    # May 2013 --RobW.
+#     if eta == chi == 0:
+#         logger.debug("Testing against simplified equations for eta == chi == 0")
+#         a = - h3
+#         b = - h1 * sin(phi) + h2 * cos(phi)
+#         sin_bit = bound(c / sqrt(a * a + b * b))
+#         mu_simplified = pi - asin(sin_bit) - atan2(b, a)
+#         mu_simplified = cut_at_minus_pi(mu_simplified)
+#         if not ne(mu_simplified, mu):
+#             raise AssertionError("mu_simplified != mu , %f!=%f" % (mu_simplified, mu))
+        
+    
+    [MU, _, _, ETA, CHI, PHI] = create_you_matrices(mu1, None, None, eta, chi, phi)
+    h_lab = MU * ETA * CHI * PHI * h_phi                                 # (11)
+    qaz1 = atan2(h_lab[0, 0] , h_lab[2, 0])
+
+    [MU, _, _, ETA, CHI, PHI] = create_you_matrices(mu2, None, None, eta, chi, phi)
+    h_lab = MU * ETA * CHI * PHI * h_phi                                 # (11)
+    qaz2 = atan2(h_lab[0, 0] , h_lab[2, 0])
+
+    return (mu1, qaz1) , (mu2, qaz2)
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/you/constraints.py b/script/test/diffcalc (copy)/diffcalc/hkl/you/constraints.py
new file mode 100644
index 0000000..1fe08d7
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/you/constraints.py	
@@ -0,0 +1,377 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.util import DiffcalcException, bold
+
+TODEG = 180 / pi
+TORAD = pi / 180
+
+NUNAME = 'gam'
+
+def filter_dict(d, keys):
+    """Return a copy of d containing only keys that are in keys"""
+    ##return {k: d[k] for k in keys} # requires Python 2.6
+    return dict((k, d[k]) for k in keys if k in d.keys())
+
+
+det_constraints = ('delta', NUNAME, 'qaz', 'naz')
+ref_constraints = ('a_eq_b', 'alpha', 'beta', 'psi')
+samp_constraints = ('mu', 'eta', 'chi', 'phi', 'mu_is_' + NUNAME)
+
+valueless_constraints = ('a_eq_b', 'mu_is_' + NUNAME)
+all_constraints = det_constraints + ref_constraints + samp_constraints
+
+
+number_single_sample = (len(det_constraints) * len(ref_constraints) *
+                        len(samp_constraints))
+
+
+class YouConstraintManager(object):
+
+    def __init__(self, hardware, fixed_constraints = {}):
+        self._hardware = hardware
+        self._constrained = {}
+#        self._tracking = []
+        self.n_phi = matrix([[0], [0], [1]])
+        self._hide_detector_constraint = False # default
+        self._fixed_samp_constraints = ()
+        self._fix_constraints(fixed_constraints)
+
+    def __str__(self):
+        lines = []
+#        TODO: Put somewhere with access to UB matrix!
+#        WIDTH = 13
+#        n_phi = self.n_phi
+#        fmt = "% 9.5f % 9.5f % 9.5f"
+#        lines.append("   n_phi:".ljust(WIDTH) +
+#                     fmt % (n_phi[0, 0], n_phi[1, 0], n_phi[2, 0]))
+#        if self._getUBMatrix():
+#            n_cryst = self._getUMatrix().I * self.n_phi
+#            lines.append("   n_cryst:".ljust(WIDTH) +
+#                         fmt % (n_cryst[0, 0], n_cryst[1, 0], n_cryst[2, 0]))
+#            n_recip = self._getUBMatrix().I * self.n_phi
+#            lines.append("   n_recip:".ljust(WIDTH) +
+#                         fmt % (n_recip[0, 0], n_recip[1, 0], n_recip[2, 0]))
+#        else:
+#            lines.append(
+#                "   n_cryst:".ljust(WIDTH) + ' "<<< No  U matrix >>>"')
+#            lines.append(
+#                "   n_recip:".ljust(WIDTH) + ' "<<< No UB matrix >>>"')
+
+        lines.extend(self.build_display_table_lines())
+        lines.append("")
+        lines.extend(self.report_constraints_lines())
+        lines.append("")
+        if (self.is_fully_constrained() and
+            not self.is_current_mode_implemented()):
+            lines.append(
+                "    Sorry, this constraint combination is not implemented")
+            lines.append("    Type 'help con' for available combinations")
+        else:
+            lines.append("    Type 'help con' for instructions")  # okay
+        return '\n'.join(lines)
+
+    @property
+    def available_constraint_names(self):
+        """list of all available constraints"""
+        return all_constraints
+
+    @property
+    def settable_constraint_names(self):
+        """list of all available constraints that have settable values"""
+        all_copy = list(all_constraints)
+        for valueless in valueless_constraints:
+            all_copy.remove(valueless)
+        return all_copy
+
+    @property
+    def all(self):  # @ReservedAssignment
+        """dictionary of all constrained values"""
+        return self._constrained.copy()
+
+    @property
+    def detector(self):
+        """dictionary of constrained detector circles"""
+        return filter_dict(self.all, det_constraints[:-1])
+
+    @property
+    def reference(self):
+        """dictionary of constrained reference circles"""
+        return filter_dict(self.all, ref_constraints)
+
+    @property
+    def sample(self):
+        """dictionary of constrained sample circles"""
+        return filter_dict(self.all, samp_constraints)
+
+    @property
+    def naz(self):
+        """dictionary with naz and value if constrained"""
+        return filter_dict(self.all, ('naz',))
+
+    @property
+    def constrained_names(self):
+        """ordered tuple of constained circles"""
+        names = self.all.keys()
+        names.sort(key=lambda name: list(all_constraints).index(name))
+        return tuple(names)
+
+    def _fix_constraints(self, fixed_constraints):
+        for name in fixed_constraints:
+            self.constrain(name)
+            self.set_constraint(name, fixed_constraints[name])
+        
+        if self.detector or self.naz:    
+            self._hide_detector_constraint = True
+        
+        fixed_samp_constraints = list(self.sample.keys())
+        if 'mu' in self.sample or NUNAME in self.detector:
+            fixed_samp_constraints.append('mu_is_' + NUNAME)
+        self._fixed_samp_constraints = tuple(fixed_samp_constraints)
+        
+
+    def is_constrained(self, name):
+        return name in self._constrained
+
+    def get_value(self, name):
+        return self._constrained[name]
+
+    def build_display_table_lines(self):
+        unfixed_samp_constraints = list(samp_constraints)
+        for name in self._fixed_samp_constraints:
+            unfixed_samp_constraints.remove(name)
+        if self._hide_detector_constraint:
+            constraint_types = (ref_constraints, unfixed_samp_constraints)
+        else:
+            constraint_types = (det_constraints, ref_constraints,
+                                unfixed_samp_constraints)
+        num_rows = max([len(col) for col in constraint_types])
+        max_name_width = max(
+            [len(name) for name in sum(constraint_types[:-1], ())])
+        
+        cells = []
+        
+        header_cells = []
+        if not self._hide_detector_constraint:
+            header_cells.append(bold('    ' + 'DET'.ljust(max_name_width)))
+        header_cells.append(bold('    ' + 'REF'.ljust(max_name_width)))
+        header_cells.append(bold('    ' + 'SAMP'))
+        cells.append(header_cells)
+        
+        underline_cells = ['    ' + '-' * max_name_width] * len(constraint_types)
+        cells.append(underline_cells)
+        
+        for n_row in range(num_rows):
+            row_cells = []
+            for col in constraint_types:
+                name = col[n_row] if n_row < len(col) else ''
+                row_cells.append(self._label_constraint(name))
+                row_cells.append(('%-' + str(max_name_width) + 's') % name)
+            cells.append(row_cells)
+        
+        lines = [' '.join(row_cells).rstrip() for row_cells in cells]
+        return lines
+
+    def _report_constraint(self, name):
+        val = self.get_constraint(name)
+        if name in valueless_constraints:
+            return "    %s" % name
+        else:
+            if val is None:
+                return "!   %-5s: ---" % name
+            else:
+                return "    %-5s: %.4f" % (name, val)
+            
+    def report_constraints_lines(self):
+        lines = []
+        required = 3 - len(self.all)
+        if required == 0:
+            pass
+        elif required == 1:
+            lines.append('!   1 more constraint required')
+        else:
+            lines.append('!   %d more constraints required' % required)
+        constraints = []
+        constraints.extend(self.detector.keys())
+        constraints.extend(self.naz.keys())
+        constraints.extend(self.reference.keys())
+        constraints.extend(sorted(self.sample.keys()))
+        for name in constraints:
+            lines.append(self._report_constraint(name))
+        return lines
+
+    def is_fully_constrained(self):
+        return len(self.all) == 3
+
+    def is_current_mode_implemented(self):
+        if not self.is_fully_constrained():
+            raise ValueError("Three constraints required")
+        
+        if len(self.sample) == 3:
+            if set(self.sample.keys()) == set(['chi', 'phi', 'eta']):
+                return True
+            return False
+
+        if len(self.sample) == 1:
+            return True
+
+        if len(self.reference) == 1:
+            return (set(self.sample.keys()) == set(['chi', 'phi']) or
+                    set(self.sample.keys()) == set(['chi', 'eta']) or
+                    set(self.sample.keys()) == set(['chi', 'mu']) or
+                    set(self.sample.keys()) == set(['mu', 'eta']))
+        
+        if len(self.detector) == 1:
+            return (set(self.sample.keys()) == set(['chi', 'phi']) or
+                    set(self.sample.keys()) == set(['mu', 'eta']) or
+                    set(self.sample.keys()) == set(['mu', 'phi'])
+                    )
+        
+        return False
+        
+
+    def _label_constraint(self, name):
+        if name == '':
+            label = '   '
+#        elif self.is_tracking(name):  # implies constrained
+#            label = '~~> '
+        elif (self.is_constrained(name) and (self.get_value(name) is None) and
+            name not in valueless_constraints):
+            label = 'o->'
+        elif self.is_constrained(name):
+            label = '-->'
+        else:
+            label = '   '
+        return label
+
+    def constrain(self, name):
+        if self.is_constraint_fixed(name):
+            raise DiffcalcException('%s is not a valid constraint name' % name)
+        if name in self.all:
+            return "%s is already constrained." % name.capitalize()
+        elif name in det_constraints:
+            return self._constrain_detector(name)
+        elif name in ref_constraints:
+            return self._constrain_reference(name)
+        elif name in samp_constraints:
+            return self._constrain_sample(name)
+        else:
+            raise DiffcalcException("%s is not a valid constraint name. Type 'con' for a table of constraint name" % name)
+
+    def is_constraint_fixed(self, name):
+        return ((name in det_constraints and self._hide_detector_constraint) or
+                (name in samp_constraints and name in self._fixed_samp_constraints))
+
+    def _constrain_detector(self, name):
+        if self.naz:
+            del self._constrained['naz']
+            self._constrained[name] = None
+            return 'Naz constraint replaced.'
+        elif self.detector:
+            constrained_name = self.detector.keys()[0]
+            del self._constrained[constrained_name]
+            self._constrained[name] = None
+            return'%s constraint replaced.' % constrained_name.capitalize()
+        elif len(self.all) == 3:  # and no detector
+            raise self._could_not_constrain_exception(name)
+        else:
+            self._constrained[name] = None
+
+    def _could_not_constrain_exception(self, name):
+        return DiffcalcException(
+            "%s could not be constrained. First un-constrain one of the\n"
+            "angles %s, %s or %s (with 'uncon')" %
+            ((name.capitalize(),) + self.constrained_names))
+
+    def _constrain_reference(self, name):
+        if self.reference:
+            constrained_name = self.reference.keys()[0]
+            del self._constrained[constrained_name]
+            self._constrained[name] = None
+            return '%s constraint replaced.' % constrained_name.capitalize()
+        elif len(self.all) == 3:  # and no reference
+            raise self._could_not_constrain_exception(name)
+        else:
+            self._constrained[name] = None
+
+    def _constrain_sample(self, name):
+        if len(self._constrained) < 3:
+            # okay, more to add
+            self._constrained[name] = None
+        # else: three constraints are set
+        elif len(self.sample) == 1:
+            # (detector and reference constraints set)
+            # it is clear which sample constraint to remove
+            constrained_name = self.sample.keys()[0]
+            del self._constrained[constrained_name]
+            self._constrained[name] = None
+            return '%s constraint replaced.' % constrained_name.capitalize()
+        else:
+            raise self._could_not_constrain_exception(name)
+
+    def unconstrain(self, name):
+        if self.is_constraint_fixed(name):
+            raise DiffcalcException('%s is not a valid constraint name')
+        if name in self._constrained:
+            del self._constrained[name]
+        else:
+            return "%s was not already constrained." % name.capitalize()
+
+    def _check_constraint_settable(self, name):
+        if name not in all_constraints:
+            raise DiffcalcException(
+                'Could not set %(name)s. This is not an available '
+                'constraint.' % locals())
+        elif name not in self.all.keys():
+            raise DiffcalcException(
+                'Could not set %(name)s. This is not currently '
+                'constrained.' % locals())
+        elif name in valueless_constraints:
+            raise DiffcalcException(
+                'Could not set %(name)s. This constraint takes no '
+                'value.' % locals())
+
+    def clear_constraints(self):
+        self._constrained = {}
+
+    def set_constraint(self, name, value):  # @ReservedAssignment
+        if self.is_constraint_fixed(name):
+            raise DiffcalcException('%s is not a valid constraint name')
+        self._check_constraint_settable(name)
+#        if name in self._tracking:
+#            raise DiffcalcException(
+#                "Could not set %s as this constraint is configured to track "
+#                "its associated\nphysical angle. First remove this tracking "
+#                "(use 'untrack %s').""" % (name, name))
+        old_value = self.get_constraint(name)
+        old = str(old_value) if old_value is not None else '---'
+        self._constrained[name] = float(value) * TORAD
+        new = str(value)
+        return "%(name)s : %(old)s --> %(new)s" % locals()
+
+    def get_constraint(self, name):
+        value = self.all[name]
+        return None if value is None else value * TODEG
+    
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/you/geometry.py b/script/test/diffcalc (copy)/diffcalc/hkl/you/geometry.py
new file mode 100644
index 0000000..d8d034a
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/you/geometry.py	
@@ -0,0 +1,219 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi
+
+from diffcalc.util import AbstractPosition, DiffcalcException
+
+TORAD = pi / 180
+TODEG = 180 / pi
+from diffcalc.util import x_rotation, z_rotation, y_rotation
+
+from diffcalc.hkl.you.constraints import NUNAME
+
+class YouGeometry(object):
+
+    def __init__(self, name, fixed_constraints, beamline_axes_transform=None):
+        self.name = name
+        self.fixed_constraints = fixed_constraints
+        # beamline_axes_transform matrix is composed of the diffcalc basis vector coordinates
+        # in the beamline coordinate system, i.e. it transforms the beamline coordinate system
+        # into the reference diffcalc one.
+        self.beamline_axes_transform = beamline_axes_transform
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        raise NotImplementedError()
+
+    def internal_position_to_physical_angles(self, internal_position):
+        raise NotImplementedError()
+
+    def create_position(self, *args):
+        return YouPosition(*args, unit='DEG')
+
+
+#==============================================================================
+#==============================================================================
+# Geometry plugins for use with 'You' hkl calculation engine
+#==============================================================================
+#==============================================================================
+
+
+class SixCircle(YouGeometry):
+    def __init__(self, beamline_axes_transform=None):
+        YouGeometry.__init__(self, 'sixc', {}, beamline_axes_transform)
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        # mu, delta, nu, eta, chi, phi
+        return YouPosition(*physical_angle_tuple, unit='DEG')
+
+    def internal_position_to_physical_angles(self, internal_position):
+        clone_position = internal_position.clone()
+        clone_position.changeToDegrees()
+        return clone_position.totuple()
+
+
+class FourCircle(YouGeometry):
+    """For a diffractometer with angles:
+          delta, eta, chi, phi
+    """
+    def __init__(self, beamline_axes_transform=None):
+        YouGeometry.__init__(self, 'fourc', {'mu': 0, NUNAME: 0}, beamline_axes_transform)
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        # mu, delta, nu, eta, chi, phi
+        delta, eta, chi, phi = physical_angle_tuple
+        return YouPosition(0, delta, 0, eta, chi, phi, 'DEG')
+
+    def internal_position_to_physical_angles(self, internal_position):
+        clone_position = internal_position.clone()
+        clone_position.changeToDegrees()
+        _, delta, _, eta, chi, phi = clone_position.totuple()
+        return delta, eta, chi, phi
+
+
+class FiveCircle(YouGeometry):
+    """For a diffractometer with angles:
+          delta, nu, eta, chi, phi
+    """
+    def __init__(self, beamline_axes_transform=None):
+        YouGeometry.__init__(self, 'fivec', {'mu': 0}, beamline_axes_transform)
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        # mu, delta, nu, eta, chi, phi
+        delta, nu, eta, chi, phi = physical_angle_tuple
+        return YouPosition(0, delta, nu, eta, chi, phi, 'DEG')
+
+    def internal_position_to_physical_angles(self, internal_position):
+        clone_position = internal_position.clone()
+        clone_position.changeToDegrees()
+        _, delta, nu, eta, chi, phi = clone_position.totuple()
+        return delta, nu, eta, chi, phi
+
+
+#==============================================================================
+
+
+def create_you_matrices(mu=None, delta=None, nu=None, eta=None, chi=None,
+                        phi=None):
+    """
+    Create transformation matrices from H. You's paper.
+    """
+    MU = None if mu is None else calcMU(mu)
+    DELTA = None if delta is None else calcDELTA(delta)
+    NU = None if nu is None else calcNU(nu)
+    ETA = None if eta is None else calcETA(eta)
+    CHI = None if chi is None else calcCHI(chi)
+    PHI = None if phi is None else calcPHI(phi)
+    return MU, DELTA, NU, ETA, CHI, PHI
+
+
+def calcNU(nu):
+    return x_rotation(nu)
+
+
+def calcDELTA(delta):
+    return z_rotation(-delta)
+
+
+def calcMU(mu_or_alpha):
+    return x_rotation(mu_or_alpha)
+
+
+def calcETA(eta):
+    return z_rotation(-eta)
+
+
+def calcCHI(chi):
+    return y_rotation(chi)
+
+
+def calcPHI(phi):
+    return z_rotation(-phi)
+
+
+def you_position_names():
+    return ('mu', 'delta', NUNAME, 'eta', 'chi', 'phi')
+
+class YouPosition(AbstractPosition):
+
+    def __init__(self, mu, delta, nu, eta, chi, phi, unit):
+        self.mu = mu
+        self.delta = delta
+        self.nu = nu
+        self.eta = eta
+        self.chi = chi
+        self.phi = phi
+        if unit not in ['DEG', 'RAD']:
+            raise DiffcalcException("Invalid angle unit value %s." % str(unit))
+        else:
+            self.unit = unit
+
+    def clone(self):
+        return YouPosition(self.mu, self.delta, self.nu, self.eta, self.chi,
+                           self.phi, self.unit)
+
+    def changeToRadians(self):
+        if self.unit == 'DEG':
+            self.mu *= TORAD
+            self.delta *= TORAD
+            self.nu *= TORAD
+            self.eta *= TORAD
+            self.chi *= TORAD
+            self.phi *= TORAD
+            self.unit = 'RAD'
+        elif self.unit == 'RAD':
+            return
+        else:
+            raise DiffcalcException("Invalid angle unit value %s." % str(self.unit))
+
+    def changeToDegrees(self):
+        if self.unit == 'RAD':
+            self.mu *= TODEG
+            self.delta *= TODEG
+            self.nu *= TODEG
+            self.eta *= TODEG
+            self.chi *= TODEG
+            self.phi *= TODEG
+            self.unit = 'DEG'
+        elif self.unit == 'DEG':
+            return
+        else:
+            raise DiffcalcException("Invalid angle unit value %s." % str(self.unit))
+
+    def totuple(self):
+        return (self.mu, self.delta, self.nu, self.eta, self.chi, self.phi)
+
+    def __str__(self):
+        mu, delta, nu, eta, chi, phi = self.totuple()
+        return ("YouPosition(mu %r delta: %r nu: %r eta: %r chi: %r  phi: %r) in %s"
+                % (mu, delta, nu, eta, chi, phi, self.unit))
+    
+    def __eq__(self, other):
+        return self.totuple() == other.totuple()
+
+
+class WillmottHorizontalPosition(YouPosition):
+
+    def __init__(self, delta=None, gamma=None, omegah=None, phi=None):
+        self.mu = 0
+        self.delta = delta
+        self.nu = gamma
+        self.eta = omegah
+        self.chi = -90
+        self.phi = phi
+        self.unit= 'DEG'
diff --git a/script/test/diffcalc (copy)/diffcalc/hkl/you/hkl.py b/script/test/diffcalc (copy)/diffcalc/hkl/you/hkl.py
new file mode 100644
index 0000000..fe3e806
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/hkl/you/hkl.py	
@@ -0,0 +1,187 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from __future__ import absolute_import
+
+from diffcalc.hkl.common import getNameFromScannableOrString
+from diffcalc.util import command
+from diffcalc.hkl.you.calc import YouHklCalculator
+from diffcalc import settings
+
+
+
+import diffcalc.ub.ub
+from diffcalc.hkl.you.constraints import YouConstraintManager
+
+__all__ = ['allhkl', 'con', 'uncon', 'hklcalc', 'constraint_manager']
+
+
+_fixed_constraints = settings.geometry.fixed_constraints  # @UndefinedVariable
+
+constraint_manager = YouConstraintManager(settings.hardware, _fixed_constraints)
+
+hklcalc = YouHklCalculator(
+    diffcalc.ub.ub.ubcalc, settings.geometry, settings.hardware, constraint_manager)
+
+
+def __str__(self):
+    return hklcalc.__str__()
+
+@command
+def con(*args):
+    """
+    con -- list available constraints and values
+    con <name> {val} -- constrains and optionally sets one constraint
+    con <name> {val} <name> {val} <name> {val} -- clears and then fully constrains
+
+    Select three constraints using 'con' and 'uncon'. Choose up to one
+    from each of the sample and detector columns and up to three from
+    the sample column.
+
+    Not all constraint combinations are currently available:
+
+        1 x samp:              all 80 of 80
+
+        2 x samp and 1 x ref:  chi & phi
+                               chi & eta
+                               chi & mu
+                               mu & eta (4 of 6)
+
+        2 x samp and 1 x det:  chi & phi
+                               mu & eta
+                               mu & phi (3 of 6)
+
+        3 x samp:              eta, chi & phi (1 of 4)
+
+    See also 'uncon'
+    """
+    args = list(args)
+    msg = _handle_con(args)
+    if (hklcalc.constraints.is_fully_constrained() and 
+        not hklcalc.constraints.is_current_mode_implemented()):
+        msg += ("\n\nWARNING:. The selected constraint combination is valid but "
+            "is not implemented.\n\nType 'help con' to see implemented combinations")
+
+    if msg:
+        print msg
+
+def _handle_con(args):
+    if not args:
+        return hklcalc.constraints.__str__()
+    
+    if len(args) > 6:
+        raise TypeError("Unexpected args: " + str(args))
+    
+    cons_value_pairs = []
+    while args:
+        scn_or_str = args.pop(0)
+        name = getNameFromScannableOrString(scn_or_str)
+        if args and isinstance(args[0], (int, long, float)):
+            value = args.pop(0)
+        else:
+            try:
+                value = settings.hardware.get_position_by_name(name)
+            except ValueError:
+                value = None
+        cons_value_pairs.append((name, value))
+    
+    if len(cons_value_pairs) == 1:
+        pass
+    elif len(cons_value_pairs) == 3:
+        hklcalc.constraints.clear_constraints()
+    else:
+        raise TypeError("Either one or three constraints must be specified")
+    for name, value in cons_value_pairs:
+        hklcalc.constraints.constrain(name)
+        if value is not None:
+            hklcalc.constraints.set_constraint(name, value)
+    return '\n'.join(hklcalc.constraints.report_constraints_lines())
+
+
+@command
+def uncon(scn_or_string):
+    """uncon <name> -- remove constraint
+
+    See also 'con'
+    """
+    name = getNameFromScannableOrString(scn_or_string)
+    hklcalc.constraints.unconstrain(name)
+    print '\n'.join(hklcalc.constraints.report_constraints_lines())
+
+@command 
+def allhkl(hkl, wavelength=None):
+    """allhkl [h k l] -- print all hkl solutions ignoring limits
+
+    """
+    hardware = hklcalc._hardware
+    geometry = hklcalc._geometry
+    if wavelength is None:
+        wavelength = hardware.get_wavelength()
+    h, k, l = hkl
+    pos_virtual_angles_pairs = hklcalc.hkl_to_all_angles(
+                                    h, k, l, wavelength)
+    cells = []
+    # virtual_angle_names = list(pos_virtual_angles_pairs[0][1].keys())
+    # virtual_angle_names.sort()
+    virtual_angle_names = ['qaz', 'psi', 'naz', 'tau', 'theta', 'alpha', 'beta']
+    header_cells = list(hardware.get_axes_names()) + [' '] + virtual_angle_names
+    cells.append(['%9s' % s for s in header_cells])
+    cells.append([''] * len(header_cells))
+    
+
+    for pos, virtual_angles in pos_virtual_angles_pairs:
+        row_cells = []
+
+
+        angle_tuple = geometry.internal_position_to_physical_angles(pos)
+        angle_tuple = hardware.cut_angles(angle_tuple)
+        for val in angle_tuple:
+            row_cells.append('%9.4f' % val)
+        
+        row_cells.append('|')
+        
+        for name in virtual_angle_names:
+            row_cells.append('%9.4f' %  virtual_angles[name])
+        cells.append(row_cells)
+            
+            
+    column_widths = []
+    for col in range(len(cells[0])):
+        widths = []
+        for row in range(len(cells)):
+            cell = cells[row][col]
+            width = len(cell.strip())
+            widths.append(width)
+        column_widths.append(max(widths))
+    
+    lines = []
+    for row_cells in cells:
+        trimmed_row_cells = []
+        for cell, width in zip(row_cells, column_widths):
+            trimmed_cell = cell.strip().rjust(width)
+            trimmed_row_cells.append(trimmed_cell)
+        lines.append('  '.join(trimmed_row_cells))
+    print '\n'.join(lines)
+
+
+commands_for_help = ['Constraints',
+                     con,
+                     uncon,
+                     'Hkl',
+                     allhkl
+                     ]
diff --git a/script/test/diffcalc (copy)/diffcalc/log.py b/script/test/diffcalc (copy)/diffcalc/log.py
new file mode 100644
index 0000000..ac4f1af
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/log.py	
@@ -0,0 +1,27 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from __future__ import absolute_import
+
+import logging
+import getpass
+
+logging.basicConfig(format="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+                    datefmt='%m/%d/%Y %I:%M:%S',
+                    filename='/tmp/diffcalc_%s.log' % getpass.getuser(),
+                    level=logging.DEBUG)
diff --git a/script/test/diffcalc (copy)/diffcalc/settings.py b/script/test/diffcalc (copy)/diffcalc/settings.py
new file mode 100644
index 0000000..5221212
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/settings.py	
@@ -0,0 +1,24 @@
+'''
+Created on Aug 5, 2013
+
+@author: walton
+'''
+import os 
+
+from diffcalc.ub.persistence import UbCalculationNonPersister
+
+# These should be by the user *before* importing other modules
+geometry = None
+hardware = None
+ubcalc_persister = UbCalculationNonPersister()
+
+axes_scannable_group = None
+energy_scannable = None
+energy_scannable_multiplier_to_get_KeV=1
+
+
+# These will be set by dcyou, dcvlieg or dcwillmot
+ubcalc_strategy = None
+angles_to_hkl_function = None  # Used by checkub to avoid coupling it to an hkl module
+include_sigtau=False
+include_reference=False
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/__init__.py b/script/test/diffcalc (copy)/diffcalc/ub/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/calc.py b/script/test/diffcalc (copy)/diffcalc/ub/calc.py
new file mode 100644
index 0000000..d71bc5e
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/calc.py	
@@ -0,0 +1,854 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc.ub.calcstate import decode_ubcalcstate
+from diffcalc.ub.calcstate import UBCalcState
+from diffcalc.ub.crystal import CrystalUnderTest
+from diffcalc.ub.reflections import ReflectionList
+from diffcalc.ub.persistence import UBCalculationJSONPersister, UBCalculationPersister
+from diffcalc.util import DiffcalcException, cross3, dot3, bold, xyz_rotation,\
+    bound
+from math import acos, cos, sin, pi
+from diffcalc.ub.reference import YouReference
+from diffcalc.ub.orientations import OrientationList
+
+try:
+    from numpy import matrix, hstack
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix, hstack
+    from numjy.linalg import norm
+
+SMALL = 1e-7
+TODEG = 180 / pi
+
+WIDTH = 13
+
+def z(num):
+    """Round to zero if small. This is useful to get rid of erroneous
+    minus signs resulting from float representation close to zero.
+    """
+    if abs(num) < SMALL:
+        num = 0
+    return num
+
+#The UB matrix is used to find or set the orientation of a set of
+#planes described by an hkl vector. The U matrix can be used to find
+#or set the orientation of the crystal lattices' y axis. If there is
+#crystal miscut the crystal lattices y axis is not parallel to the
+#crystals optical surface normal. For surface diffraction experiments,
+#where not only the crystal lattice must be oriented appropriately but
+#so must the crystal's optical surface, two angles tau and sigma are
+#used to describe the difference between the two. Sigma is (minus) the
+#ammount of chi axis rotation and tau (minus) the ammount of phi axis
+#rotation needed to move the surface normal into the direction of the
+
+
+class PaperSpecificUbCalcStrategy(object):
+
+    def calculate_q_phi(self, pos):
+        """Calculate hkl in the phi frame in units of 2 * pi / lambda from
+        pos object in radians"""
+        raise NotImplementedError()
+
+
+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
+        try:
+            self._ROT = diffractometerPluginObject.beamline_axes_transform
+        except AttributeError:
+            self._ROT = None
+        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())
+        orientlist = OrientationList()
+        reference = YouReference(self._get_UB)
+        self._state = UBCalcState(name=name, reflist=reflist, orientlist=orientlist, 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._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.or0 is not None:
+            if self._state.or1 is None:
+                self.calculate_UB_from_primary_only()
+            else:
+                if self._state.reflist:
+                    self.calculate_UB()
+                elif self._state.orientlist:
+                    self.calculate_UB_from_orientation()
+                else:
+                    pass
+        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, self._ROT))
+        
+        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())
+        
+        lines.append("")
+        lines.append(bold("CRYSTAL ORIENTATIONS"))
+        lines.append("")
+        
+        lines.extend(self._state.orientlist.str_lines(R=self._ROT))
+        
+        return '\n'.join(lines)
+
+    def str_lines_u(self):
+        lines = []
+        fmt = "% 9.5f % 9.5f % 9.5f"
+        try:
+            U = self._ROT.I * self.U * self._ROT
+        except AttributeError:
+            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')
+        try:
+            rotation_axis = cross3(self._ROT * y, self._ROT * self.U * y)
+        except TypeError:
+            rotation_axis = cross3(y, self.U * y)
+        if abs(norm(rotation_axis)) < SMALL:
+            lines.append("   miscut 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("   miscut:")
+            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"
+        try:
+            RI = self._ROT.I
+            B = self._state.crystal.B
+            UB = RI * self.UB * B.I * self._ROT * B
+        except AttributeError:
+            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 or"
+            print "         'orientub' to recalculate with old orientations."
+
+### 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_phi(self):
+        return self._state.reference.n_phi
+    
+    n_phi = property(_get_n_phi)
+    
+    def set_n_phi_configured(self, n_phi):
+        try:
+            self._state.reference.n_phi_configured = self._ROT.I * n_phi
+        except AttributeError:
+            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(), R=self._ROT))
+
+### 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 is not 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 is not 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()
+
+### Orientations ###
+
+    def add_orientation(self, h, k, l, x, y, z, tag, time):
+        """add_reflection(h, k, l, x, y, z, tag=None) -- adds a crystal orientation
+        """
+        if self._state.orientlist is None:
+            raise DiffcalcException("No UBCalculation loaded")
+        try:
+            xyz_rot = self._ROT * matrix([[x],[y],[z]])
+            xr, yr, zr = xyz_rot.T.tolist()[0]
+            self._state.orientlist.add_orientation(h, k, l, xr, yr, zr, tag, time)
+        except TypeError:
+            self._state.orientlist.add_orientation(h, k, l, x, y, z, tag, time)
+        self.save()  # incase autocalculateUbAndReport fails
+
+        # If second reflection has just been added then calculateUB
+        if len(self._state.orientlist) == 2:
+            self._autocalculateOrientationUbAndReport()
+        self.save()
+
+    def edit_orientation(self, num, h, k, l, x, y, z, tag, time):
+        """
+        edit_orientation(num, h, k, l, x, y, z, tag=None) -- edit a crystal reflection        """
+        if self._state.orientlist is None:
+            raise DiffcalcException("No UBCalculation loaded")
+        try:
+            xyz_rot = self._ROT * matrix([[x],[y],[z]])
+            xr, yr, zr = xyz_rot.T.tolist()[0]
+            self._state.orientlist.edit_orientation(num, h, k, l, xr, yr, zr, tag, time)
+        except TypeError:
+            self._state.orientlist.edit_orientation(num, h, k, l, x, y, z, tag, time)
+
+        # If first or second orientation has been changed and there are
+        # two orientations then recalculate  UB
+        if (num == 1 or num == 2) and len(self._state.orientlist) == 2:
+            self._autocalculateOrientationUbAndReport()
+        self.save()
+
+    def get_orientation(self, num):
+        """--> ( [h, k, l], [x, y, z], tag, time )
+        num starts at 1"""
+        try:
+            hkl, xyz, tg, tm = self._state.orientlist.getOrientation(num)
+            xyz_rot = self._ROT.I * matrix([[xyz[0]],[xyz[1]],[xyz[2]]])
+            xyz_lst = xyz_rot.T.tolist()[0]
+            return hkl, xyz_lst, tg, tm
+        except AttributeError:
+            return self._state.orientlist.getOrientation(num)
+
+
+    def get_number_orientations(self):
+        return 0 if self._state.orientlist is None else len(self._state.reflist)
+
+    def del_orientation(self, orientationNumber):
+        self._state.orientlist.removeOrientation(orientationNumber)
+        if ((orientationNumber == 2) and (self._U is not None)):
+            self._autocalculateOrientationUbAndReport()
+        self.save()
+
+    def swap_orientations(self, num1, num2):
+        self._state.orientlist.swap_orientations(num1, num2)
+        if ((num1 == 2 or num2 == 2) and
+            (self._U is not None)):
+            self._autocalculateOrientationUbAndReport()
+        self.save()
+
+    def _autocalculateOrientationUbAndReport(self):
+        if len(self._state.orientlist) < 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 'orientub' 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_from_orientation()
+
+#    @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."
+
+        if self._ROT is not None:
+            self._U = self._ROT * m * self._ROT.I
+        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
+        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")
+
+        if self._ROT is not None:
+            self._UB = self._ROT * m
+        else:
+            self._UB = m
+        self._state.configure_calc_type(manual_UB=self._UB)
+        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 _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
+        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(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
+        u1p = self._strategy.calculate_q_phi(pos1)
+        u2p = self._strategy.calculate_q_phi(pos2)
+        
+        self._calc_UB(h1, h2, u1p, u2p)
+
+    def calculate_UB_from_orientation(self):
+        """
+        Calculate orientation matrix. Uses first two crystal orientations.
+        """
+
+        # 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 crystal orientations
+        if self._state.orientlist is None:
+            raise DiffcalcException("Cannot calculate a U matrix until a "
+                                    "UBCalculation has been started with "
+                                    "'newub'")
+        try:
+            (h1, x1, _, _) = self._state.orientlist.getOrientation(1)
+            (h2, x2, _, _) = self._state.orientlist.getOrientation(2)
+        except IndexError:
+            raise DiffcalcException(
+                "Two crystal orientations are required to calculate a U matrix")
+        h1 = matrix([h1]).T  # row->column
+        h2 = matrix([h2]).T
+        u1p = matrix([x1]).T
+        u2p = matrix([x2]).T
+
+        self._calc_UB(h1, h2, u1p, u2p)
+
+    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 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)
+            if self.is_ub_calculated() and add_miscut:
+                self._U = rot_matrix * self._U
+            else:
+                self._U = rot_matrix
+        else:
+            rot_matrix = xyz_rotation(xyz, angle)
+            try:
+                rot_matrix =  self._ROT * rot_matrix * self._ROT.I
+            except TypeError:
+                pass
+            if self.is_ub_calculated() and add_miscut:
+                self._U = rot_matrix * self._U
+            else:
+                self._U = rot_matrix
+        self._state.configure_calc_type(manual_U=self._U)
+        self._UB = self._U * self._state.crystal.B
+        self.print_reference()
+        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) / self._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
+        return sc, (name, sc * a1, sc* a2, sc * 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]])
+        try:
+            axis = cross3(self._ROT.I * q_vec, self._ROT.I * hkl_nphi)
+        except AttributeError:
+            axis = cross3(q_vec, hkl_nphi)
+        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]
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/calcstate.py b/script/test/diffcalc (copy)/diffcalc/ub/calcstate.py
new file mode 100644
index 0000000..1e8f438
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/calcstate.py	
@@ -0,0 +1,220 @@
+from diffcalc.hkl.vlieg.geometry import VliegPosition
+from diffcalc.ub.crystal import CrystalUnderTest
+from diffcalc.ub.reflections import ReflectionList, _Reflection
+from math import pi
+import datetime  # @UnusedImport For crazy time eval code!
+from diffcalc.ub.reference import YouReference
+from diffcalc.ub.orientations import _Orientation, OrientationList
+
+try:
+    from collection import OrderedDict
+except ImportError:
+    from simplejson import OrderedDict
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+
+TODEG = 180 / pi
+
+
+class UBCalcState():
+    
+    def __init__(self, name=None, crystal=None, reflist=None, orientlist=None, tau=0, sigma=0,
+                 manual_U=None, manual_UB=None, or0=None, or1=None, reference=None):
+
+        assert reflist is not None
+        self.name = name
+        self.crystal = crystal
+        self.reflist = reflist
+        self.orientlist = orientlist
+        self.tau = tau  # degrees
+        self.sigma = sigma  # degrees
+        self.manual_U = manual_U
+        self.manual_UB = manual_UB
+        self.or0 = or0
+        self.or1 = or1
+        self.reference = reference
+        
+    @property
+    def is_okay_to_autocalculate_ub(self):
+        nothing_set = ((self.manual_U is None) and 
+                       (self.manual_UB is None) and 
+                       (self.or0 is None) and 
+                       (self.or1 is None))
+        or0_and_or1_used =  (self.or0 is not None) and (self.or1 is not None)
+        return nothing_set or or0_and_or1_used
+    
+
+    def configure_calc_type(self,
+                            manual_U=None,
+                            manual_UB=None,
+                            or0=None,
+                            or1=None):
+        self.manual_U = manual_U
+        self.manual_UB = manual_UB
+        self.or0 = or0
+        self.or1 = or1
+
+
+class UBCalcStateEncoder(json.JSONEncoder):
+    
+    def default(self, obj):
+        
+        if isinstance(obj, UBCalcState):
+            d = OrderedDict()
+            d['name'] = obj.name
+            d['crystal'] = obj.crystal
+            d['reflist'] = obj.reflist
+            d['orientlist'] = obj.orientlist
+            d['tau'] = obj.tau
+            d['sigma'] = obj.sigma
+            d['reference'] = obj.reference
+            d['u'] = obj.manual_U
+            d['ub'] = obj.manual_UB
+            d['or0'] = obj.or0
+            d['or1'] = obj.or1
+            
+            return d
+        
+        if isinstance(obj, CrystalUnderTest):
+            return repr([obj._name, obj._a1, obj._a2, obj._a3, obj._alpha1 * TODEG,
+                         obj._alpha2 * TODEG, obj._alpha3 * TODEG])
+            
+        if isinstance(obj, matrix):
+            l = [', '.join((repr(e) for e in row)) for row in obj.tolist()]
+            return l
+        
+        if isinstance(obj, ReflectionList):
+            d = OrderedDict()
+            for n, ref in enumerate(obj._reflist):
+                d[str(n+1)] = ref
+            return d
+
+        if isinstance(obj, _Reflection):
+            d = OrderedDict()
+            d['tag'] = obj.tag
+            d['hkl'] = repr([obj.h, obj.k, obj.l])
+            d['pos'] = repr(list(obj.pos.totuple()))
+            d['energy'] = obj.energy
+            dt = eval(obj.time)  # e.g. --> datetime.datetime(2013, 8, 5, 15, 47, 7, 962432)
+            d['time'] = None if dt is None else dt.isoformat()
+            return d
+        
+        if isinstance(obj, OrientationList):
+            d = OrderedDict()
+            for n, orient in enumerate(obj._orientlist):
+                d[str(n+1)] = orient
+            return d
+
+        if isinstance(obj, _Orientation):
+            d = OrderedDict()
+            d['tag'] = obj.tag
+            d['hkl'] = repr([obj.h, obj.k, obj.l])
+            d['xyz'] = repr([obj.x, obj.y, obj.z])
+            dt = eval(obj.time)  # e.g. --> datetime.datetime(2013, 8, 5, 15, 47, 7, 962432)
+            d['time'] = None if dt is None else dt.isoformat()
+            return d
+        
+        if isinstance(obj, YouReference):
+            d = OrderedDict()
+            if obj.n_hkl_configured is not None:
+                d['n_hkl_configured'] = repr(obj.n_hkl_configured.T.tolist()[0])
+            else:
+                d['n_hkl_configured'] = None
+            if obj.n_phi_configured is not None:
+                d['n_phi_configured'] = repr(obj.n_phi_configured.T.tolist()[0])
+            else:
+                d['n_phi_configured'] = None
+            return d
+        
+        
+        return json.JSONEncoder.default(self, obj)
+
+
+def decode_ubcalcstate(state, geometry, diffractometer_axes_names):
+
+    # Backwards compatibility code
+    orientlist_=OrientationList([])
+    try:
+        orientlist_=decode_orientlist(state['orientlist'])
+    except KeyError:
+        pass
+    return UBCalcState(
+        name=state['name'],
+        crystal=state['crystal'] and CrystalUnderTest(*eval(state['crystal'])),
+        reflist=decode_reflist(state['reflist'], geometry, diffractometer_axes_names),
+        orientlist=orientlist_,
+        tau=state['tau'],
+        sigma=state['sigma'],
+        manual_U=state['u'] and decode_matrix(state['u']),
+        manual_UB=state['ub'] and decode_matrix(state['ub']),
+        or0=state['or0'],
+        or1=state['or1'],
+        reference=decode_reference(state.get('reference', None))
+    )
+
+
+def decode_matrix(rows):
+    return matrix([[eval(e) for e in row.split(', ')] for row in rows])
+
+
+def decode_reflist(reflist_dict, geometry, diffractometer_axes_names):
+    reflections = []
+    for key in sorted(reflist_dict.keys()):
+        reflections.append(decode_reflection(reflist_dict[key], geometry))
+        
+    return ReflectionList(geometry, diffractometer_axes_names, reflections)
+
+
+def decode_orientlist(orientlist_dict):
+    orientations = []
+    for key in sorted(orientlist_dict.keys()):
+        orientations.append(decode_orientation(orientlist_dict[key]))
+        
+    return OrientationList(orientations)
+
+
+def decode_reflection(ref_dict, geometry):
+    h, k, l = eval(ref_dict['hkl'])
+    time = ref_dict['time'] and gt(ref_dict['time'])
+    pos_tuple = eval(ref_dict['pos'])
+    try:
+        position = geometry.create_position(*pos_tuple)
+    except AttributeError:
+        position = VliegPosition(*pos_tuple)
+    return _Reflection(h, k, l, position, ref_dict['energy'], str(ref_dict['tag']), repr(time))
+
+
+def decode_reference(ref_dict):
+    reference = YouReference(None)  # TODO: We can't set get_ub method yet (tangles!)
+    if ref_dict:   
+        nhkl = ref_dict.get('n_hkl_configured', None)
+        nphi = ref_dict.get('n_phi_configured', None)
+        if nhkl:
+            reference.n_hkl_configured = matrix([eval(nhkl)]).T
+        if nphi:
+            reference.n_phi_configured = matrix([eval(nphi)]).T
+    return reference
+
+
+def decode_orientation(orient_dict):
+    h, k, l = eval(orient_dict['hkl'])
+    x, y, z = eval(orient_dict['xyz'])
+    time = orient_dict['time'] and gt(orient_dict['time'])
+    return _Orientation(h, k, l, x, y, z, str(orient_dict['tag']), repr(time))
+
+
+# From: http://stackoverflow.com/questions/127803/how-to-parse-iso-formatted-date-in-python
+def gt(dt_str):
+    dt, _, us= dt_str.partition(".")
+    dt= datetime.datetime.strptime(dt, "%Y-%m-%dT%H:%M:%S")
+    us= int(us.rstrip("Z"), 10)
+    return dt + datetime.timedelta(microseconds=us)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/crystal.py b/script/test/diffcalc (copy)/diffcalc/ub/crystal.py
new file mode 100644
index 0000000..84072d9
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/crystal.py	
@@ -0,0 +1,147 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi, cos, sin, acos, sqrt
+from diffcalc.util import angle_between_vectors
+
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+TORAD = pi / 180
+TODEG = 180 / pi
+SMALL = 1e-7
+
+def z(num):
+    """Round to zero if small. This is useful to get rid of erroneous
+    minus signs resulting from float representation close to zero.
+    """
+    if abs(num) < SMALL:
+        num = 0
+    return num
+
+
+class CrystalUnderTest(object):
+    """
+    Contains the lattice parameters and calculated B matrix for the crytsal
+    under test. Also Calculates the distance between planes at a given hkl
+    value.
+
+    The lattice paraemters can be specified and then if desired saved to a
+    __library to be loaded later. The parameters are persisted across restarts.
+    Lattices stored in config/var/crystals.xml .
+    """
+
+    def __init__(self, name, a, b, c, alpha, beta, gamma):
+        '''Creates a new lattice and calculates related values.
+
+        Keyword arguments:
+            name -- a string
+            a,b,c,alpha,beta,gamma -- lengths and angles (in degrees)
+        '''
+
+        self._name = name
+
+        # Set the direct lattice parameters
+        self._a1 = a1 = a
+        self._a2 = a2 = b
+        self._a3 = a3 = c
+        self._alpha1 = alpha1 = alpha * TORAD
+        self._alpha2 = alpha2 = beta * TORAD
+        self._alpha3 = alpha3 = gamma * TORAD
+
+        # Calculate the reciprocal lattice parameters
+        self._beta1 = acos((cos(alpha2) * cos(alpha3) - cos(alpha1)) /
+                           (sin(alpha2) * sin(alpha3)))
+
+        self._beta2 = beta2 = acos((cos(alpha1) * cos(alpha3) - cos(alpha2)) /
+                                   (sin(alpha1) * sin(alpha3)))
+
+        self._beta3 = beta3 = acos((cos(alpha1) * cos(alpha2) - cos(alpha3)) /
+                                   (sin(alpha1) * sin(alpha2)))
+
+        volume = (a1 * a2 * a3 *
+                  sqrt(1 + 2 * cos(alpha1) * cos(alpha2) * cos(alpha3) -
+                       cos(alpha1) ** 2 - cos(alpha2) ** 2 - cos(alpha3) ** 2))
+
+        self._b1 = b1 = 2 * pi * a2 * a3 * sin(alpha1) / volume
+        self._b2 = b2 = 2 * pi * a1 * a3 * sin(alpha2) / volume
+        self._b3 = b3 = 2 * pi * a1 * a2 * sin(alpha3) / volume
+
+        # Calculate the BMatrix from the direct and reciprical parameters.
+        # Reference: Busang and Levy (1967)
+        self._bMatrix = matrix([
+            [b1, b2 * cos(beta3), b3 * cos(beta2)],
+            [0.0, b2 * sin(beta3), -b3 * sin(beta2) * cos(alpha1)],
+            [0.0, 0.0, 2 * pi / a3]])
+
+    @property
+    def B(self):
+        '''
+        Returns the B matrix, may be null if crystal is not set, or if there
+        was a problem calculating this'''
+        return self._bMatrix
+
+    def get_hkl_plane_distance(self, hkl):
+        '''Calculates and returns the distance between planes'''
+        hkl = matrix([hkl])
+        bReduced = self._bMatrix / (2 * pi)
+        bMT = bReduced.I * bReduced.T.I
+        return 1.0 / sqrt((hkl * bMT.I * hkl.T)[0,0])
+
+    def get_hkl_plane_angle(self, hkl1, hkl2):
+        '''Calculates and returns the angle between [hkl1] and [hkl2] planes'''
+        hkl1 = matrix([hkl1]).T
+        hkl2 = matrix([hkl2]).T
+        nphi1 = self._bMatrix * hkl1
+        nphi2 = self._bMatrix * hkl2
+        angle = angle_between_vectors(nphi1, nphi2)
+        return angle
+
+    def __str__(self):
+        '''    Returns lattice name and all set and calculated parameters'''
+        return '\n'.join(self.str_lines())
+
+    def str_lines(self):
+        WIDTH = 13
+        if self._name is None:
+            return ["   none specified"]
+
+        b = self._bMatrix
+        lines = []
+        lines.append("   name:".ljust(WIDTH) + self._name.rjust(9))
+        lines.append("")
+        lines.append("   a, b, c:".ljust(WIDTH) +
+                     "% 9.5f % 9.5f % 9.5f" % (self.getLattice()[1:4]))
+        lines.append(" " * WIDTH +
+                     "% 9.5f % 9.5f % 9.5f" % (self.getLattice()[4:]))
+        lines.append("")
+
+        fmt = "% 9.5f % 9.5f % 9.5f"
+        lines.append("   B matrix:".ljust(WIDTH) +
+                     fmt % (z(b[0, 0]), z(b[0, 1]), z(b[0, 2])))
+        lines.append(' ' * WIDTH + fmt % (z(b[1, 0]), z(b[1, 1]), z(b[1, 2])))
+        lines.append(' ' * WIDTH + fmt % (z(b[2, 0]), z(b[2, 1]), z(b[2, 2])))
+        return lines
+
+    def getLattice(self):
+        return(self._name, self._a1, self._a2, self._a3, self._alpha1 * TODEG,
+               self._alpha2 * TODEG, self._alpha3 * TODEG)
+
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/orientations.py b/script/test/diffcalc (copy)/diffcalc/ub/orientations.py
new file mode 100644
index 0000000..1726136
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/orientations.py	
@@ -0,0 +1,118 @@
+###
+# Copyright 2008-2017 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from copy import deepcopy
+import datetime  # @UnusedImport for the eval below
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.util import DiffcalcException, bold
+
+
+class _Orientation:
+    """A orientation"""
+    def __init__(self, h, k, l, x, y, z, tag, time):
+
+        self.h = float(h)
+        self.k = float(k)
+        self.l = float(l)
+        self.x = float(x)
+        self.y = float(y)
+        self.z = float(z)
+        self.tag = tag
+        self.time = time  # Saved as e.g. repr(datetime.now())
+
+    def __str__(self):
+        return ("h=%-4.2f k=%-4.2f l=%-4.2f  x=%-4.2f "
+                "y=%-4.2f z=%-4.2 "
+                "  %-s %s" % (self.h, self.k, self.l,
+                self.x, self.y, self.z,
+                self.tag, self.time))
+
+
+class OrientationList:
+
+    def __init__(self, orientations=None):
+        self._orientlist = orientations if orientations else []
+            
+
+    def add_orientation(self, h, k, l, x, y, z, tag, time):
+        """adds a crystal orientation
+        """
+        self._orientlist += [_Orientation(h, k, l, x, y, z, tag,
+                                     time.__repr__())]
+
+    def edit_orientation(self, num, h, k, l, x, y, z, tag, time):
+        """num starts at 1"""
+        try:
+            self._orientlist[num - 1] = _Orientation(h, k, l, x, y, z, tag,
+                                                time.__repr__())
+        except IndexError:
+            raise DiffcalcException("There is no orientation " + repr(num)
+                                     + " to edit.")
+
+    def getOrientation(self, num):
+        """
+        getOrientation(num) --> ( [h, k, l], [x, y, z], tag, time ) --
+        num starts at 1
+        """
+        r = deepcopy(self._orientlist[num - 1])  # for convenience
+        return [r.h, r.k, r.l], [r.x, r.y, r.z], r.tag, eval(r.time)
+
+    def removeOrientation(self, num):
+        del self._orientlist[num - 1]
+
+    def swap_orientations(self, num1, num2):
+        orig1 = self._orientlist[num1 - 1]
+        self._orientlist[num1 - 1] = self._orientlist[num2 - 1]
+        self._orientlist[num2 - 1] = orig1
+
+    def __len__(self):
+        return len(self._orientlist)
+
+    def __str__(self):
+        return '\n'.join(self.str_lines())
+
+    def str_lines(self, R=None):
+        if not self._orientlist:
+            return ["   <<< none specified >>>"]
+
+        lines = []
+
+        str_format = ("     %5s %5s %5s   %5s %5s %5s  TAG")
+        values = ('H', 'K', 'L', 'X', 'Y', 'Z')
+        lines.append(bold(str_format % values))
+
+        for n in range(len(self._orientlist)):
+            orient_tuple = self.getOrientation(n + 1)
+            [h, k, l], [x, y, z], tag, _ = orient_tuple
+            try:
+                xyz_rot = R.I * matrix([[x],[y],[z]])
+                xr, yr, zr = xyz_rot.T.tolist()[0]
+            except AttributeError:
+                xr, yr, zr = x ,y ,z
+            if tag is None:
+                tag = ""
+            str_format = ("  %2d % 4.2f % 4.2f % 4.2f  " +
+                      "% 4.2f % 4.2f % 4.2f  %s")
+            values = (n + 1, h, k, l, xr, yr, zr, tag)
+            lines.append(str_format % values)
+        return lines
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/persistence.py b/script/test/diffcalc (copy)/diffcalc/ub/persistence.py
new file mode 100644
index 0000000..526dbcd
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/persistence.py	
@@ -0,0 +1,151 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from __future__ import with_statement
+
+import os, glob
+from diffcalc.ub.calcstate import UBCalcStateEncoder
+import datetime
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+
+def is_writable(directory):
+    """Return true if the file is writable from the current user
+    """
+    probe = os.path.join(directory, "probe")
+    try:
+        open(probe, 'w')
+    except IOError:
+        return False
+    else:
+        os.remove(probe)
+        return True
+
+def check_directory_appropriate(directory):
+
+    if not os.path.exists(directory):
+        raise IOError("'%s' does not exist")
+    
+    if not os.path.isdir(directory):
+        raise IOError("'%s' is not a directory")
+    
+    if not is_writable(directory):
+        raise IOError("'%s' is not writable")
+
+
+class UBCalculationJSONPersister(object):
+
+    def __init__(self, directory):
+        check_directory_appropriate(directory)
+        self.directory = directory
+        self.description = directory
+        
+    def filepath(self, name):
+        return os.path.join(self.directory, name + '.json')
+        
+    def save(self, state, name):
+        # FORMAT = '%Y-%m-%d %H:%M:%S'
+        # time_string = datetime.datetime.strftime(datetime.datetime.now(), FORMAT)
+        with open(self.filepath(name), 'w') as f:
+            json.dump(state, f, indent=4, cls=UBCalcStateEncoder)
+
+    def load(self, name):
+        with open(self.filepath(name), 'r') as f:
+            return json.load(f)
+
+    def list(self):  # @ReservedAssignment
+        files = self._get_save_files()
+        return [os.path.basename(f + '.json').split('.json')[0] for f in files]
+
+    def list_metadata(self):       
+        metadata = []
+        for f in self._get_save_files():            
+            dt = datetime.datetime.fromtimestamp(os.path.getmtime(f))
+            metadata.append(dt.strftime('%d %b %Y (%H:%M)'))
+        return metadata
+    
+    def _get_save_files(self):
+        files = filter(os.path.isfile, glob.glob(os.path.join(self.directory, '*.json')))
+        files.sort(key=lambda x: os.path.getmtime(x))
+        files.reverse()
+        return files
+
+    def remove(self, name):
+        os.remove(self.filepath(name))
+
+
+
+class UBCalculationPersister(object):
+    """Attempts to the use the gda's database to store ub calculation state
+    """
+    def __init__(self):
+        try:
+            from uk.ac.diamond.daq.persistence.jythonshelf import LocalJythonShelfManager
+            from uk.ac.diamond.daq.persistence.jythonshelf.LocalDatabase import \
+                LocalDatabaseException
+            self.shelf = LocalJythonShelfManager.getLocalObjectShelf(
+                'diffcalc.ub')
+        except ImportError, e:
+            print ("!!! UBCalculationPersister could not import the gda database "
+                   "code: " + repr(e))
+            self.shelf = None
+        except LocalDatabaseException, e:
+            print ("UBCalculationPersister could not connect to the gda "
+                   "database: " + repr(e))
+            self.shelf = None
+        self.description = 'GDA sql database'
+
+    def save(self, state, key):
+        if self.shelf is not None:
+            self.shelf[key] = state
+        else:
+            print "<<<no database available to save UB calculation>>>"
+
+    def load(self, name):
+        if self.shelf is not None:
+            return self.shelf[name]
+        else:
+            raise IOError("Could not load UB calculation: no database available")
+
+    def list(self):  # @ReservedAssignment
+        if self.shelf is not None:
+            names = list(self.shelf.keys())
+            names.sort()
+            return names
+        else:
+            return []
+
+    def remove(self, name):
+        if self.shelf is not None:
+            del self.shelf[name]
+        else:
+            raise IOError("Could not remove UB calculation: no database available")
+
+
+class UbCalculationNonPersister(UBCalculationPersister):
+    """
+    A version of UBCalculationPersister that simply stores to a local dict
+    rather than a database. Useful for testing.
+    """
+    def __init__(self):
+        self.shelf = dict()
+        self.description = 'memory only'
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/reference.py b/script/test/diffcalc (copy)/diffcalc/ub/reference.py
new file mode 100644
index 0000000..53a8e4b
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/reference.py	
@@ -0,0 +1,99 @@
+from math import pi, acos
+
+try:
+    from numpy import matrix
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix
+    from numjy.linalg import norm
+
+from diffcalc.util import cross3, dot3
+
+
+SMALL = 1e-7
+TODEG = 180 / pi
+
+class YouReference(object):
+    
+    def __init__(self, get_UB):
+        self.get_UB = get_UB  # callable
+        self._n_phi_configured = None
+        self._n_hkl_configured = None
+        self._set_n_phi_configured(matrix('0; 0; 1'))
+    
+    def _set_n_phi_configured(self, n_phi):
+        self._n_phi_configured = n_phi
+        self._n_hkl_configured = None
+    
+    def _get_n_phi_configured(self):
+        return self._n_phi_configured
+    
+    n_phi_configured = property(_get_n_phi_configured, _set_n_phi_configured)
+                    
+    def _set_n_hkl_configured(self, n_hkl):
+        self._n_phi_configured = None
+        self._n_hkl_configured = n_hkl
+        
+    def _get_n_hkl_configured(self):
+        return self._n_hkl_configured
+    
+    n_hkl_configured = property(_get_n_hkl_configured, _set_n_hkl_configured)
+    
+    @property
+    def n_phi(self):
+        n_phi = (self.get_UB() * self._n_hkl_configured if self._n_phi_configured is None 
+                 else self._n_phi_configured)
+        return n_phi / norm(n_phi)
+        
+    @property
+    def n_hkl(self):
+        n_hkl = (self.get_UB().I * self._n_phi_configured if self._n_hkl_configured is None
+                  else self._n_hkl_configured) 
+        return n_hkl / norm(n_hkl)
+    
+    def _pretty_vector(self, m):
+        return ' '.join([('% 9.5f' % e).rjust(9) for e in m.T.tolist()[0]])
+    
+    def repr_lines(self, ub_calculated, WIDTH=9, R=None):
+        SET_LABEL = ' <- set'
+        lines = []
+        if self._n_phi_configured is not None:
+            nphi_label = SET_LABEL
+            nhkl_label = ''
+        elif self._n_hkl_configured is not None:
+            nphi_label = ''
+            nhkl_label = SET_LABEL
+        else:
+            raise AssertionError("Neither a manual n_phi nor n_hkl is configured")
+        
+        if ub_calculated:
+            try:
+                lines.append("   n_phi:".ljust(WIDTH) + self._pretty_vector(R.I * self.n_phi) + nphi_label)
+            except AttributeError:
+                lines.append("   n_phi:".ljust(WIDTH) + self._pretty_vector(self.n_phi) + nphi_label)
+            lines.append("   n_hkl:".ljust(WIDTH) + self._pretty_vector(self.n_hkl) + nhkl_label)
+            try:
+                rotation_axis = R.I * cross3(matrix('0; 0; 1'), self.n_phi)
+            except AttributeError:
+                rotation_axis = cross3(matrix('0; 0; 1'), self.n_phi)
+            if abs(norm(rotation_axis)) < SMALL:
+                lines.append("   normal:".ljust(WIDTH) + "  None")
+            else:
+                rotation_axis = rotation_axis * (1 / norm(rotation_axis))
+                cos_rotation_angle = dot3(matrix('0; 0; 1'), self.n_phi)
+                rotation_angle = acos(cos_rotation_angle)
+                lines.append("   normal:")
+                lines.append("      angle:".ljust(WIDTH) + "% 9.5f" % (rotation_angle * TODEG))
+                lines.append("      axis:".ljust(WIDTH) + self._pretty_vector(rotation_axis))
+ 
+        else:  # no ub calculated
+            if self._n_phi_configured is not None:
+                try:
+                    lines.append("   n_phi:".ljust(WIDTH) + self._pretty_vector(R.I * self._n_phi_configured) + SET_LABEL)
+                except AttributeError:
+                    lines.append("   n_phi:".ljust(WIDTH) + self._pretty_vector(self._n_phi_configured) + SET_LABEL)
+            elif self._n_hkl_configured is not None:
+                lines.append("   n_hkl:".ljust(WIDTH) + self._pretty_vector(self._n_hkl_configured) + SET_LABEL)
+
+        return lines
+    
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/reflections.py b/script/test/diffcalc (copy)/diffcalc/ub/reflections.py
new file mode 100644
index 0000000..c447468
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/reflections.py	
@@ -0,0 +1,126 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from copy import deepcopy
+import datetime  # @UnusedImport for the eval below
+from diffcalc.util import DiffcalcException, bold
+from diffcalc.hkl.vlieg.geometry import VliegPosition
+
+
+class _Reflection:
+    """A reflection"""
+    def __init__(self, h, k, l, position, energy, tag, time):
+
+        self.h = float(h)
+        self.k = float(k)
+        self.l = float(l)
+        self.pos = position
+        self.tag = tag
+        self.energy = float(energy)      # energy=12.39842/lambda
+        self.wavelength = 12.3984 / self.energy
+        self.time = time  # Saved as e.g. repr(datetime.now())
+
+    def __str__(self):
+        return ("energy=%-6.3f h=%-4.2f k=%-4.2f l=%-4.2f  alpha=%-8.4f "
+                "delta=%-8.4f gamma=%-8.4f omega=%-8.4f chi=%-8.4f "
+                "phi=%-8.4f  %-s %s" % (self.energy, self.h, self.k, self.l,
+                self.pos.alpha, self.pos.delta, self.pos.gamma, self.pos.omega,
+                self.pos.chi, self.pos.phi, self.tag, self.time))
+
+
+class ReflectionList:
+
+    def __init__(self, diffractometerPluginObject, externalAngleNames, reflections=None):
+        self._geometry = diffractometerPluginObject
+        self._externalAngleNames = externalAngleNames
+        self._reflist = reflections if reflections else []
+            
+
+    def add_reflection(self, h, k, l, position, energy, tag, time):
+        """adds a reflection, position in degrees
+        """
+        if type(position) in (list, tuple):
+            try:
+                position = self._geometry.create_position(*position)
+            except AttributeError:
+                position = VliegPosition(*position)
+        self._reflist += [_Reflection(h, k, l, position, energy, tag,
+                                     time.__repr__())]
+
+    def edit_reflection(self, num, h, k, l, position, energy, tag, time):
+        """num starts at 1"""
+        if type(position) in (list, tuple):
+            position = VliegPosition(*position)
+        try:
+            self._reflist[num - 1] = _Reflection(h, k, l, position, energy, tag,
+                                                time.__repr__())
+        except IndexError:
+            raise DiffcalcException("There is no reflection " + repr(num)
+                                     + " to edit.")
+
+    def getReflection(self, num):
+        """
+        getReflection(num) --> ( [h, k, l], position, energy, tag, time ) --
+        num starts at 1 position in degrees
+        """
+        r = deepcopy(self._reflist[num - 1])  # for convenience
+        return [r.h, r.k, r.l], deepcopy(r.pos), r.energy, r.tag, eval(r.time)
+
+    def get_reflection_in_external_angles(self, num):
+        """getReflection(num) --> ( [h, k, l], (angle1...angleN), energy, tag )
+        -- num starts at 1 position in degrees"""
+        r = deepcopy(self._reflist[num - 1])  # for convenience
+        externalAngles = self._geometry.internal_position_to_physical_angles(r.pos)
+        result = [r.h, r.k, r.l], externalAngles, r.energy, r.tag, eval(r.time)
+        return result
+
+    def removeReflection(self, num):
+        del self._reflist[num - 1]
+
+    def swap_reflections(self, num1, num2):
+        orig1 = self._reflist[num1 - 1]
+        self._reflist[num1 - 1] = self._reflist[num2 - 1]
+        self._reflist[num2 - 1] = orig1
+
+    def __len__(self):
+        return len(self._reflist)
+
+    def __str__(self):
+        return '\n'.join(self.str_lines())
+
+    def str_lines(self):
+        axes = tuple(s.upper() for s in self._externalAngleNames)
+        if not self._reflist:
+            return ["   <<< none specified >>>"]
+
+        lines = []
+
+        format = ("     %6s %5s %5s %5s  " + "%8s " * len(axes) + " TAG")
+        values = ('ENERGY', 'H', 'K', 'L') + axes
+        lines.append(bold(format % values))
+
+        for n in range(len(self._reflist)):
+            ref_tuple = self.get_reflection_in_external_angles(n + 1)
+            [h, k, l], externalAngles, energy, tag, _ = ref_tuple
+            if tag is None:
+                tag = ""
+            format = ("  %2d %6.3f % 4.2f % 4.2f % 4.2f  " +
+                      "% 8.4f " * len(axes) + " %s")
+            values = (n + 1, energy, h, k, l) + externalAngles + (tag,)
+            lines.append(format % values)
+        return lines
diff --git a/script/test/diffcalc (copy)/diffcalc/ub/ub.py b/script/test/diffcalc (copy)/diffcalc/ub/ub.py
new file mode 100644
index 0000000..afd2f47
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/ub/ub.py	
@@ -0,0 +1,768 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc import settings
+from diffcalc.ub.calc import UBCalculation
+
+from math import asin, pi
+from datetime import datetime
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+
+from diffcalc.util import getInputWithDefault as promptForInput, \
+    promptForNumber, promptForList, allnum, isnum, bold, xyz_rotation
+from diffcalc.util import command
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+# When using ipython magic, these functions must not be imported to the top
+# level namespace. Doing so will stop them from being called with magic.
+
+__all__ = ['addorient', 'addref', 'c2th', 'hklangle', 'calcub', 'delorient', 'delref', 'editorient',
+           'editref', 'listub', 'loadub', 'newub', 'orientub', 'saveubas', 'setlat',
+           'addmiscut', 'setmiscut', 'setu', 'setub', 'showorient', 'showref', 'swaporient',
+           'swapref', 'trialub', 'checkub', 'ub', 'ubcalc', 'rmub', 'clearorient',
+           'clearref', 'lastub', 'refineub']
+
+if settings.include_sigtau:
+    __all__.append('sigtau')
+
+if settings.include_reference:
+    __all__.append('setnphi')
+    __all__.append('setnhkl')
+
+
+ubcalc = UBCalculation(settings.hardware,
+                       settings.geometry,
+                       settings.ubcalc_persister,
+                       settings.ubcalc_strategy,
+                       settings.include_sigtau,
+                       settings.include_reference)
+
+
+
+### UB state ###
+
+@command
+def newub(name=None):
+    """newub {'name'} -- start a new ub calculation name
+    """
+    if name is None:
+        # interactive
+        name = promptForInput('calculation name')
+        ubcalc.start_new(name)
+        setlat()
+    elif isinstance(name, str):
+        # just trying might cause confusion here
+        ubcalc.start_new(name)
+    else:
+        raise TypeError()
+
+@command
+def loadub(name_or_num):
+    """loadub 'name' | num -- load an existing ub calculation
+    """
+    if isinstance(name_or_num, str):
+        ubcalc.load(name_or_num)
+    else:
+        ubcalc.load(ubcalc.listub()[int(name_or_num)])
+
+@command
+def lastub():
+    """lastub -- load the last used ub calculation
+    """
+    try:
+        lastub_name = ubcalc.listub()[0]
+        print "Loading ub calculation: '%s'" % lastub_name
+        loadub(0)
+    except IndexError:
+        print "WARNING: There is no record of the last ub calculation used"
+
+@command
+def rmub(name_or_num):
+    """rmub 'name'|num -- remove existing ub calculation
+    """
+    if isinstance(name_or_num, str):
+        ubcalc.remove(name_or_num)
+    else:
+        ubcalc.remove(ubcalc.listub()[int(name_or_num)])
+
+@command
+def listub():
+    """listub -- list the ub calculations available to load.
+    """
+    if hasattr(ubcalc._persister, 'description'):
+        print "UB calculations in: " + ubcalc._persister.description
+    else:
+        print "UB calculations:"
+    print
+    ubnames = ubcalc.listub()
+    # TODO: whole mechanism of making two calls is messy
+    try:
+        ub_metadata = ubcalc.listub_metadata()
+    except AttributeError:
+        ub_metadata = [''] * len(ubnames)
+    
+    for n, name, data in zip(range(len(ubnames)), ubnames, ub_metadata):
+        print "%2i) %-15s %s" % (n, name, data)
+
+@command
+def saveubas(name):
+    """saveubas 'name' -- save the ub calculation with a new name
+    """
+    if isinstance(name, str):
+        # just trying might cause confusion here
+        ubcalc.saveas(name)
+    else:
+        raise TypeError()
+
+@command
+def ub():
+    """ub -- show the complete state of the ub calculation
+    """
+    #wavelength = float(hardware.get_wavelength())
+    #energy = float(hardware.get_energy())
+    print ubcalc.__str__()
+
+@command
+def refineub(*args):
+    """
+    refineub {[h k l]} {pos} -- refine unit cell dimensions and U matrix to match diffractometer angles for a given hkl value
+    """
+    if len(args) > 0:
+        args = list(args)
+        h, k, l = args.pop(0)
+        if not (isnum(h) and isnum(k) and isnum(l)):
+            raise TypeError()
+    else:
+        h = promptForNumber('h', 0.)
+        k = promptForNumber('k', 0.)
+        l = promptForNumber('l', 0.)
+        if None in (h, k, l):
+            _handleInputError("h,k and l must all be numbers")
+    if len(args) == 1:
+        pos = settings.geometry.physical_angles_to_internal_position(  # @UndefinedVariable
+                args.pop(0))
+    elif len(args) == 0:
+        reply = promptForInput('current pos', 'y')
+        if reply in ('y', 'Y', 'yes'):
+            positionList = settings.hardware.get_position()  # @UndefinedVariable
+        else:
+            currentPos = settings.hardware.get_position()  # @UndefinedVariable
+            positionList = []
+            names = settings.hardware.get_axes_names()  # @UndefinedVariable
+            for i, angleName in enumerate(names):
+                val = promptForNumber(angleName.rjust(7), currentPos[i])
+                if val is None:
+                    _handleInputError("Please enter a number, or press"
+                                          " Return to accept default!")
+                    return
+                positionList.append(val)
+        pos = settings.geometry.physical_angles_to_internal_position(positionList)  # @UndefinedVariable
+    else:
+        raise TypeError()
+    
+    pos.changeToRadians()
+    scale, lat = ubcalc.rescale_unit_cell(h, k, l, pos)
+    if scale:
+        lines = ["Unit cell scaling factor:".ljust(9) +
+                         "% 9.5f" % scale]
+        lines.append("Refined crystal lattice:")
+        lines.append("   a, b, c:".ljust(9) +
+                         "% 9.5f % 9.5f % 9.5f" % (lat[1:4]))
+        lines.append(" " * 12 +
+                         "% 9.5f % 9.5f % 9.5f" % (lat[4:]))
+        lines.append("")
+        print '\n'.join(lines)
+        reply = promptForInput('Update crystal settings?', 'y')
+        if reply in ('y', 'Y', 'yes'):
+            ubcalc.set_lattice(*lat)
+    else:
+        print "No unit cell mismatch detected"
+    mc_angle, mc_axis = ubcalc.calc_miscut(h, k, l, pos)
+    if mc_angle:
+        lines = ["Miscut parameters:",]
+        lines.append("      angle:".ljust(9) + "% 9.5f" % mc_angle)
+        lines.append("       axis:".ljust(9) + "% 9.5f % 9.5f % 9.5f" % tuple(mc_axis))
+        print '\n'.join(lines)
+        reply = promptForInput('Apply miscut parameters?', 'y')
+        if reply in ('y', 'Y', 'yes'):
+            ubcalc.set_miscut(mc_axis, -mc_angle * TORAD, True)
+    else:
+        print "No miscut detected for the given settings"
+
+### UB lattice ###
+
+@command
+def setlat(name=None, *args):
+    """
+    setlat  -- interactively enter lattice parameters (Angstroms and Deg)
+    setlat name a -- assumes cubic
+    setlat name a b -- assumes tetragonal
+    setlat name a b c -- assumes ortho
+    setlat name a b c gamma -- assumes mon/hex with gam not equal to 90
+    setlat name a b c alpha beta gamma -- arbitrary
+    """
+
+    if name is None:  # Interactive
+        name = promptForInput("crystal name")
+        a = promptForNumber('    a', 1)
+        b = promptForNumber('    b', a)
+        c = promptForNumber('    c', a)
+        alpha = promptForNumber('alpha', 90)
+        beta = promptForNumber('beta', 90)
+        gamma = promptForNumber('gamma', 90)
+        ubcalc.set_lattice(name, a, b, c, alpha, beta, gamma)
+
+    elif (isinstance(name, str) and
+          len(args) in (1, 2, 3, 4, 6) and
+          allnum(args)):
+        # first arg is string and rest are numbers
+        ubcalc.set_lattice(name, *args)
+    else:
+        raise TypeError()
+
+@command
+def c2th(hkl, en=None):
+    """
+    c2th [h k l]  -- calculate two-theta angle for reflection
+    """
+    if en is None:
+        wl = settings.hardware.get_wavelength()  # @UndefinedVariable
+    else:
+        wl = 12.39842 / en
+    d = ubcalc.get_hkl_plane_distance(hkl)
+    if wl > (2 * d):
+        raise ValueError(
+            'Reflection un-reachable as wavelength (%f) is more than twice\n'
+            'the plane distance (%f)' % (wl, d))
+    try:
+        return 2.0 * asin(wl / (d * 2)) * TODEG
+    except ValueError as e:
+        raise ValueError('asin(wl / (d * 2) with wl=%f and d=%f: ' %(wl, d) + e.args[0])
+    
+
+@command
+def hklangle(hkl1, hkl2):
+    """
+    hklangle [h1 k1 l1] [h2 k2 l2]  -- calculate angle between [h1 k1 l1] and [h2 k2 l2] planes
+    """
+    return ubcalc.get_hkl_plane_angle(hkl1, hkl2) * TODEG
+
+### Surface and reference vector stuff ###
+
+@command
+def sigtau(sigma=None, tau=None):
+    """sigtau {sigma tau} -- sets or displays sigma and tau"""
+    if sigma is None and tau is None:
+        chi = settings.hardware.get_position_by_name('chi')  # @UndefinedVariable
+        phi = settings.hardware.get_position_by_name('phi')  # @UndefinedVariable
+        _sigma, _tau = ubcalc.sigma, ubcalc.tau
+        print "sigma, tau = %f, %f" % (_sigma, _tau)
+        print "  chi, phi = %f, %f" % (chi, phi)
+        sigma = promptForInput("sigma", -chi)
+        tau = promptForInput("  tau", -phi)
+        ubcalc.sigma = sigma
+        ubcalc.tau = tau
+    else:
+        ubcalc.sigma = float(sigma)
+        ubcalc.tau = float(tau)
+
+
+@command
+def setnphi(xyz=None):
+    """setnphi {[x y z]} -- sets or displays n_phi reference"""
+    if xyz is None:
+        ubcalc.print_reference()
+    else:
+        ubcalc.set_n_phi_configured(_to_column_vector_triple(xyz))
+        ubcalc.print_reference()
+
+@command
+def setnhkl(hkl=None):
+    """setnhkl {[h k l]} -- sets or displays n_hkl reference"""
+    if hkl is None:
+        ubcalc.print_reference()
+    else:
+        ubcalc.set_n_hkl_configured(_to_column_vector_triple(hkl))
+        ubcalc.print_reference()
+ 
+ 
+def _to_column_vector_triple(o):
+    m = matrix(o)
+    if m.shape == (1, 3):
+        return m.T
+    elif m.shape == (3, 1):
+        return m
+    else:
+        raise ValueError("Unexpected shape matrix: " + m)
+    
+### UB refelections ###
+
+@command
+def showref():
+    """showref -- shows full reflection list"""
+    if ubcalc._state.reflist:
+        print '\n'.join(ubcalc._state.reflist.str_lines())
+    else:
+        print "<<< No reflections stored >>>"
+
+@command
+def addref(*args):
+    """
+    addref -- add reflection interactively
+    addref [h k l] {'tag'} -- add reflection with current position and energy
+    addref [h k l] (p1, .., pN) energy {'tag'} -- add arbitrary reflection
+    """
+
+    if len(args) == 0:
+        h = promptForNumber('h', 0.)
+        k = promptForNumber('k', 0.)
+        l = promptForNumber('l', 0.)
+        if None in (h, k, l):
+            _handleInputError("h,k and l must all be numbers")
+        reply = promptForInput('current pos', 'y')
+        if reply in ('y', 'Y', 'yes'):
+            positionList = settings.hardware.get_position()  # @UndefinedVariable
+            energy = settings.hardware.get_energy()  # @UndefinedVariable
+        else:
+            currentPos = settings.hardware.get_position()  # @UndefinedVariable
+            positionList = []
+            names = settings.hardware.get_axes_names()  # @UndefinedVariable
+            for i, angleName in enumerate(names):
+                val = promptForNumber(angleName.rjust(7), currentPos[i])
+                if val is None:
+                    _handleInputError("Please enter a number, or press"
+                                          " Return to accept default!")
+                    return
+                positionList.append(val)
+            muliplier = settings.hardware.energyScannableMultiplierToGetKeV  # @UndefinedVariable
+            energy = promptForNumber('energy', settings.hardware.get_energy() / muliplier)  # @UndefinedVariable
+            if val is None:
+                _handleInputError("Please enter a number, or press "
+                                      "Return to accept default!")
+                return
+            energy = energy * muliplier
+        tag = promptForInput("tag")
+        if tag == '':
+            tag = None
+        pos = settings.geometry.physical_angles_to_internal_position(positionList)  # @UndefinedVariable
+        ubcalc.add_reflection(h, k, l, pos, energy, tag,
+                                   datetime.now())
+    elif len(args) in (1, 2, 3, 4):
+        args = list(args)
+        h, k, l = args.pop(0)
+        if not (isnum(h) and isnum(k) and isnum(l)):
+            raise TypeError()
+        if len(args) >= 2:
+            pos = settings.geometry.physical_angles_to_internal_position(  # @UndefinedVariable
+                args.pop(0))
+            energy = args.pop(0)
+            if not isnum(energy):
+                raise TypeError()
+        else:
+            pos = settings.geometry.physical_angles_to_internal_position(  # @UndefinedVariable
+                settings.hardware.get_position())  # @UndefinedVariable
+            energy = settings.hardware.get_energy()  # @UndefinedVariable
+        if len(args) == 1:
+            tag = args.pop(0)
+            if not isinstance(tag, str):
+                raise TypeError()
+        else:
+            tag = None
+        ubcalc.add_reflection(h, k, l, pos, energy, tag,
+                                   datetime.now())
+    else:
+        raise TypeError()
+
+@command
+def editref(num):
+    """editref num -- interactively edit a reflection.
+    """
+    num = int(num)
+
+    # Get old reflection values
+    [oldh, oldk, oldl], oldExternalAngles, oldEnergy, oldTag, oldT = \
+        ubcalc.get_reflection_in_external_angles(num)
+    del oldT  # current time will be used.
+
+    h = promptForNumber('h', oldh)
+    k = promptForNumber('k', oldk)
+    l = promptForNumber('l', oldl)
+    if None in (h, k, l):
+        _handleInputError("h,k and l must all be numbers")
+    reply = promptForInput('update position with current hardware setting',
+                           'n')
+    if reply in ('y', 'Y', 'yes'):
+        positionList = settings.hardware.get_position()  # @UndefinedVariable
+        energy = settings.hardware.get_energy()  # @UndefinedVariable
+    else:
+        positionList = []
+        names = settings.hardware.get_axes_names()  # @UndefinedVariable
+        for i, angleName in enumerate(names):
+            val = promptForNumber(angleName.rjust(7), oldExternalAngles[i])
+            if val is None:
+                _handleInputError("Please enter a number, or press "
+                                      "Return to accept default!")
+                return
+            positionList.append(val)
+        muliplier = settings.hardware.energyScannableMultiplierToGetKeV  # @UndefinedVariable
+        energy = promptForNumber('energy', oldEnergy / muliplier)
+        if val is None:
+            _handleInputError("Please enter a number, or press Return "
+                                  "to accept default!")
+            return
+        energy = energy * muliplier
+    tag = promptForInput("tag", oldTag)
+    if tag == '':
+        tag = None
+    pos = settings.geometry.physical_angles_to_internal_position(positionList)  # @UndefinedVariable
+    ubcalc.edit_reflection(num, h, k, l, pos, energy, tag,
+                                datetime.now())
+
+@command
+def delref(num):
+    """delref num -- deletes a reflection (numbered from 1)
+    """
+    ubcalc.del_reflection(int(num))
+    
+@command
+def clearref():
+    """clearref -- deletes all the reflections
+    """
+    while ubcalc.get_number_reflections():
+        ubcalc.del_reflection(1)   
+
+@command
+def swapref(num1=None, num2=None):
+    """
+    swapref -- swaps first two reflections used for calulating U matrix
+    swapref num1 num2 -- swaps two reflections (numbered from 1)
+    """
+    if num1 is None and num2 is None:
+        ubcalc.swap_reflections(1, 2)
+    elif isinstance(num1, int) and isinstance(num2, int):
+        ubcalc.swap_reflections(num1, num2)
+    else:
+        raise TypeError()
+
+### U calculation from crystal orientation
+@command
+def showorient():
+    """showorient -- shows full list of crystal orientations"""
+    if ubcalc._state.orientlist:
+        print '\n'.join(ubcalc._state.orientlist.str_lines())
+    else:
+        print "<<< No crystal orientations stored >>>"
+
+@command
+def addorient(*args):
+    """
+    addorient -- add crystal orientation interactively
+    addorient [h k l] [x y z] {'tag'} -- add crystal orientation in laboratory frame
+    """
+
+    if len(args) == 0:
+        h = promptForNumber('h', 0.)
+        k = promptForNumber('k', 0.)
+        l = promptForNumber('l', 0.)
+        if None in (h, k, l):
+            _handleInputError("h,k and l must all be numbers")
+
+        x = promptForNumber('x', 0.)
+        y = promptForNumber('y', 0.)
+        z = promptForNumber('z', 0.)
+        if None in (x, y, z):
+            _handleInputError("x,y and z must all be numbers")
+
+        tag = promptForInput("tag")
+        if tag == '':
+            tag = None
+        ubcalc.add_orientation(h, k, l, x , y, z, tag,
+                                   datetime.now())
+    elif len(args) in (1, 2, 3):
+        args = list(args)
+        h, k, l = args.pop(0)
+        if not (isnum(h) and isnum(k) and isnum(l)):
+            raise TypeError()
+        x, y, z = args.pop(0)
+        if not (isnum(x) and isnum(y) and isnum(z)):
+            raise TypeError()
+        if len(args) == 1:
+            tag = args.pop(0)
+            if not isinstance(tag, str):
+                raise TypeError()
+        else:
+            tag = None
+        ubcalc.add_orientation(h, k, l, x, y ,z, tag,
+                                   datetime.now())
+    else:
+        raise TypeError()
+
+@command
+def editorient(num):
+    """editorient num -- interactively edit a crystal orientation.
+    """
+    num = int(num)
+
+    # Get old reflection values
+    [oldh, oldk, oldl], [oldx, oldy, oldz], oldTag, oldT = \
+        ubcalc.get_orientation(num)
+    del oldT  # current time will be used.
+
+    h = promptForNumber('h', oldh)
+    k = promptForNumber('k', oldk)
+    l = promptForNumber('l', oldl)
+    if None in (h, k, l):
+        _handleInputError("h,k and l must all be numbers")
+    x = promptForNumber('x', oldx)
+    y = promptForNumber('y', oldy)
+    z = promptForNumber('z', oldz)
+    if None in (x, y, z):
+        _handleInputError("x,y and z must all be numbers")
+    tag = promptForInput("tag", oldTag)
+    if tag == '':
+        tag = None
+    ubcalc.edit_orientation(num, h, k, l, x, y, z, tag,
+                                datetime.now())
+
+@command
+def delorient(num):
+    """delorient num -- deletes a crystal orientation (numbered from 1)
+    """
+    ubcalc.del_orientation(int(num))
+    
+@command
+def clearorient():
+    """clearorient -- deletes all the crystal orientations
+    """
+    while ubcalc.get_number_orientations():
+        ubcalc.del_orientation(1)
+
+@command
+def swaporient(num1=None, num2=None):
+    """
+    swaporient -- swaps first two crystal orientations used for calulating U matrix
+    swaporient num1 num2 -- swaps two crystal orientations (numbered from 1)
+    """
+    if num1 is None and num2 is None:
+        ubcalc.swap_orientations(1, 2)
+    elif isinstance(num1, int) and isinstance(num2, int):
+        ubcalc.swap_orientations(num1, num2)
+    else:
+        raise TypeError()
+
+
+### UB calculations ###
+
+@command
+def setu(U=None):
+    """setu {[[..][..][..]]} -- manually set U matrix
+    """
+    if U is None:
+        U = _promptFor3x3MatrixDefaultingToIdentity()
+        if U is None:
+            return  # an error will have been printed or thrown
+    if _is3x3TupleOrList(U) or _is3x3Matrix(U):
+        ubcalc.set_U_manually(U)
+    else:
+        raise TypeError("U must be given as 3x3 list or tuple")
+
+@command
+def setub(UB=None):
+    """setub {[[..][..][..]]} -- manually set UB matrix"""
+    if UB is None:
+        UB = _promptFor3x3MatrixDefaultingToIdentity()
+        if UB is None:
+            return  # an error will have been printed or thrown
+    if _is3x3TupleOrList(UB):
+        ubcalc.set_UB_manually(UB)
+    else:
+        raise TypeError("UB must be given as 3x3 list or tuple")
+
+def _promptFor3x3MatrixDefaultingToIdentity():
+    estring = "Please enter a number, or press Return to accept default!"
+    row1 = promptForList("row1", (1, 0, 0))
+    if row1 is None:
+        _handleInputError(estring)
+        return None
+    row2 = promptForList("row2", (0, 1, 0))
+    if row2 is None:
+        _handleInputError(estring)
+        return None
+    row3 = promptForList("row3", (0, 0, 1))
+    if row3 is None:
+        _handleInputError(estring)
+        return None
+    return [row1, row2, row3]
+
+@command
+def calcub():
+    """calcub -- (re)calculate U matrix from ref1 and ref2.
+    """
+    ubcalc.calculate_UB()
+
+@command
+def trialub():
+    """trialub -- (re)calculate U matrix from ref1 only (check carefully).
+    """
+    ubcalc.calculate_UB_from_primary_only()
+
+@command
+def orientub():
+    """orientub -- (re)calculate U matrix from orient1 and orient2.
+    """
+    ubcalc.calculate_UB_from_orientation()
+
+
+    # This command requires the ubcalc
+
+def checkub():
+    """checkub -- show calculated and entered hkl values for reflections.
+    """
+
+    s = "\n    %7s  %4s  %4s  %4s    %6s   %6s   %6s     TAG\n" % \
+    ('ENERGY', 'H', 'K', 'L', 'H_COMP', 'K_COMP', 'L_COMP')
+    s = bold(s)
+    nref = ubcalc.get_number_reflections()
+    if not nref:
+        s += "<<empty>>"
+    for n in range(nref):
+        hklguess, pos, energy, tag, _ = ubcalc.get_reflection(n + 1)
+        wavelength = 12.39842 / energy
+        hkl = settings.angles_to_hkl_function(pos.inRadians(), wavelength, ubcalc.UB)
+        h, k, l = hkl
+        if tag is None:
+            tag = ""
+        s += ("% 2d % 6.4f % 4.2f % 4.2f % 4.2f   % 6.4f  % 6.4f  "
+              "% 6.4f  %6s\n" % (n + 1, energy, hklguess[0],
+              hklguess[1], hklguess[2], h, k, l, tag))
+    print s
+
+
+@command
+def addmiscut(*args):
+    """addmiscut angle {[x y z]} -- apply miscut to U matrix using a specified miscut angle in degrees and a rotation axis"""
+    
+    if len(args) == 0:
+        _handleInputError("Please specify a miscut angle in degrees "
+                          "and, optionally, a rotation axis (default: [0 1 0])")
+    else:
+        args=list(args)
+        angle = args.pop(0)
+        rad_angle = float(angle) * TORAD
+        if len(args) == 0:
+            xyz = None
+        else:
+            xyz = args.pop(0)
+        ubcalc.set_miscut(xyz, rad_angle, True)
+
+@command
+def setmiscut(*args):
+    """setmiscut angle {[x y z]} -- manually set U matrix using a specified miscut angle in degrees and a rotation axis (default: [0 1 0])"""
+    
+    if len(args) == 0:
+        _handleInputError("Please specify a miscut angle in degrees "
+                          "and, optionally, a rotation axis (default: [0 1 0])")
+    else:
+        args=list(args)
+        angle = args.pop(0)
+        rad_angle = float(angle) * TORAD
+        if len(args) == 0:
+            xyz = None
+        else:
+            xyz = args.pop(0)
+        ubcalc.set_miscut(xyz, rad_angle, False)
+
+commands_for_help = ['State',
+                     newub,
+                     loadub,
+                     lastub,
+                     listub,
+                     rmub,
+                     saveubas,
+                     ub,
+                     'Lattice',
+                     setlat,
+                     c2th,
+                     hklangle]
+
+if ubcalc.include_reference:
+    commands_for_help.extend([
+                     'Reference (surface)',
+                     setnphi,
+                     setnhkl])
+
+if ubcalc.include_sigtau:
+    commands_for_help.extend([
+                     'Surface',
+                     sigtau])
+
+commands_for_help.extend([
+                     'Reflections',
+                     showref,
+                     addref,
+                     editref,
+                     delref,
+                     clearref,
+                     swapref,
+                     'Orientations',
+                     showorient,
+                     addorient,
+                     editorient,
+                     delorient,
+                     clearorient,
+                     swaporient,
+                     'UB matrix',
+                     checkub,
+                     setu,
+                     setub,
+                     calcub,
+                     orientub,
+                     trialub,
+                     refineub,
+                     addmiscut,
+                     setmiscut])
+
+
+
+def _is3x3TupleOrList(m):
+    if type(m) not in (list, tuple):
+        return False
+    if len(m) != 3:
+        return False
+    for mrow in m:
+        if type(mrow) not in (list, tuple):
+            return False
+        if len(mrow) != 3:
+            return False
+    return True
+
+
+def _is3x3Matrix(m):
+    return isinstance(m, matrix) and tuple(m.shape) == (3, 3)
+        
+
+def _handleInputError(msg):
+    raise TypeError(msg)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcalc/util.py b/script/test/diffcalc (copy)/diffcalc/util.py
new file mode 100644
index 0000000..873040c
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcalc/util.py	
@@ -0,0 +1,347 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi, acos, cos, sin
+from functools import wraps
+import textwrap
+
+try:
+    from gda.jython.commands.InputCommands import requestInput as raw_input
+    GDA = True
+except ImportError:
+    GDA = False
+    pass  # raw_input unavailable in gda
+try:
+    from numpy import matrix
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix
+    from numjy.linalg import norm
+
+
+# from http://physics.nist.gov/
+h_in_eV_per_s = 4.135667516E-15
+c = 299792458
+TWELVEISH = c * h_in_eV_per_s  # 12.39842
+
+
+SMALL = 1e-10
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+COLOURISE_TERMINAL_OUTPUT = not GDA
+
+def bold(s):
+    if not COLOURISE_TERMINAL_OUTPUT:
+        return s
+    else:    
+        BOLD = '\033[1m'
+        END = '\033[0m'
+        return BOLD + s + END
+
+
+def x_rotation(th):
+    return matrix(((1, 0, 0), (0, cos(th), -sin(th)), (0, sin(th), cos(th))))
+
+
+def y_rotation(th):
+    return matrix(((cos(th), 0, sin(th)), (0, 1, 0), (-sin(th), 0, cos(th))))
+
+
+def z_rotation(th):
+    return matrix(((cos(th), -sin(th), 0), (sin(th), cos(th), 0), (0, 0, 1)))
+
+
+def xyz_rotation(u, angle):
+    u = [list(u), [0, 0, 0], [0, 0, 0]]
+    u = matrix(u) / norm(matrix(u))
+    e11=u[0,0]**2+(1-u[0,0]**2)*cos(angle)
+    e12=u[0,0]*u[0,1]*(1-cos(angle))-u[0,2]*sin(angle)
+    e13=u[0,0]*u[0,2]*(1-cos(angle))+u[0,1]*sin(angle)
+    e21=u[0,0]*u[0,1]*(1-cos(angle))+u[0,2]*sin(angle)
+    e22=u[0,1]**2+(1-u[0,1]**2)*cos(angle)
+    e23=u[0,1]*u[0,2]*(1-cos(angle))-u[0,0]*sin(angle)
+    e31=u[0,0]*u[0,2]*(1-cos(angle))-u[0,1]*sin(angle)
+    e32=u[0,1]*u[0,2]*(1-cos(angle))+u[0,0]*sin(angle)
+    e33=u[0,2]**2+(1-u[0,2]**2)*cos(angle)
+    return matrix([[e11,e12,e13],[e21,e22,e23],[e31,e32,e33]])
+
+
+class DiffcalcException(Exception):
+    """Error caused by user misuse of diffraction calculator.
+    """
+    def __str__(self):
+        lines = []
+        for msg_line in self.message.split('\n'):
+            lines.append('* ' + msg_line)
+        width = max(len(l) for l in lines)
+        lines.insert(0, '\n\n' + '*' * width)
+        lines.append('*' * width)
+        return '\n'.join(lines)
+
+
+class AbstractPosition(object):
+
+    def inRadians(self):
+        pos = self.clone()
+        pos.changeToRadians()
+        return pos
+
+    def inDegrees(self):
+        pos = self.clone()
+        pos.changeToDegrees()
+        return pos
+
+    def changeToRadians(self):
+        raise NotImplementedError()
+
+    def changeToDegrees(self):
+        raise NotImplementedError()
+
+    def totuple(self):
+        raise NotImplementedError()
+
+
+### Matrices
+
+def cross3(x, y):
+    """z = cross3(x ,y) -- where x, y & z are 3*1 Jama matrices"""
+    [[x1], [x2], [x3]] = x.tolist()
+    [[y1], [y2], [y3]] = y.tolist()
+    return matrix([[x2 * y3 - x3 * y2],
+                   [x3 * y1 - x1 * y3],
+                   [x1 * y2 - x2 * y1]])
+
+
+def dot3(x, y):
+    """z = dot3(x ,y) -- where x, y are 3*1 Jama matrices"""
+    return x[0, 0] * y[0, 0] + x[1, 0] * y[1, 0] + x[2, 0] * y[2, 0]
+
+
+def angle_between_vectors(a, b):
+    costheta = dot3(a * (1 / norm(a)), b * (1 / norm(b)))
+    return acos(bound(costheta))
+
+
+## Math
+
+def bound(x):
+    """
+    moves x between -1 and 1. Used to correct for rounding errors which may
+    have moved the sin or cosine of a value outside this range.
+    """
+    if abs(x) > (1 + SMALL):
+        raise AssertionError(
+            "The value (%f) was unexpectedly too far outside -1 or 1 to "
+            "safely bound. Please report this." % x)
+    if x > 1:
+        return 1
+    if x < -1:
+        return -1
+    return x
+
+
+def matrixToString(m):
+    ''' str = matrixToString(m) --- displays a Jama matrix m as a string
+    '''
+    toReturn = ''
+    for row in m.array:
+        for el in row:
+            toReturn += str(el) + '\t'
+        toReturn += '\n'
+    return toReturn
+
+
+def nearlyEqual(first, second, tolerance):
+    if type(first) in (int, float):
+        return abs(first - second) <= tolerance
+
+    if type(first) != type(matrix([[1]])):
+        # lists
+        first = matrix([list(first)])
+        second = matrix([list(second)])
+    diff = first - (second)
+    return norm(diff) <= tolerance
+
+
+def radiansEquivilant(first, second, tolerance):
+    if abs(first - second) <= tolerance:
+        return True
+    if abs((first - 2 * pi) - second) <= tolerance:
+        return True
+    if abs((first + 2 * pi) - second) <= tolerance:
+        return True
+    if abs(first - (second - 2 * pi)) <= tolerance:
+        return True
+    if abs(first - (second + 2 * pi)) <= tolerance:
+        return True
+
+    return False
+
+
+def degreesEquivilant(first, second, tolerance):
+    return radiansEquivilant(first * TORAD, second * TORAD, tolerance)
+
+
+def differ(first, second, tolerance):
+    """Returns error message if the norm of the difference between two arrays
+    or numbers is greater than the given tolerance. Else returns False.
+    """
+    # TODO: Fix spaghetti
+    nonArray = False
+    if type(first) in (int, float):
+        if type(second) not in (int, float):
+            raise TypeError(
+                "If first is an int or float, so must second. "
+                "first=%s, second=%s" & (repr(first), repr(second)))
+        first = [first]
+        second = [second]
+        nonArray = True
+    if not isinstance(first, matrix):
+        first = matrix([list(first)])
+    if not isinstance(second, matrix):
+        second = matrix([list(second)])
+    diff = first - second
+    if norm(diff) >= tolerance:
+        if nonArray:
+            return ('%s!=%s' %
+                    (repr(first.tolist()[0][0]), repr(second.tolist()[0][0])))
+        return ('%s!=%s' %
+                (repr(tuple(first.tolist()[0])),
+                repr(tuple(second.tolist()[0]))))
+    return False
+
+
+### user input
+
+def getInputWithDefault(prompt, default=""):
+    """
+    Prompts user for input and returns if possible a float or a list of floats,
+    or if failing this a string.    default may be a number, array of numbers,
+    or string.
+    """
+    if default is not "":
+        # Generate default string
+        if type(default) in (list, tuple):
+            defaultString = ""
+            for val in default:
+                defaultString += str(val) + ' '
+            defaultString = defaultString.strip()
+        else:
+            defaultString = str(default)
+        prompt = str(prompt) + '[' + defaultString + ']: '
+    else:
+        prompt = str(prompt) + ': '
+
+    rawresult = raw_input(prompt)
+
+    # Return default if no input provided
+    if rawresult == "":
+        return default
+
+    # Try to process result into list of numbers
+    try:
+        result = []
+        for val in rawresult.split():
+            result.append(float(val))
+    except ValueError:
+        # return a string
+        return rawresult
+    if len(result) == 1:
+        result = result[0]
+    return result
+
+
+class MockRawInput(object):
+    def __init__(self, toReturnList):
+        if type(toReturnList) != list:
+            toReturnList = [toReturnList]
+        self.toReturnList = toReturnList
+
+    def __call__(self, prompt):
+        toReturn = self.toReturnList.pop(0)
+        if type(toReturn) != str:
+            raise TypeError
+        print prompt + toReturn
+        return toReturn
+
+
+def getMessageFromException(e):
+    try:  # Jython
+        return e.args[0]
+    except:
+        try:  # Python
+            return e.message
+        except:
+            # Java
+            return e.args[0]
+
+
+def promptForNumber(prompt, default=""):
+    val = getInputWithDefault(prompt, default)
+    if type(val) not in (float, int):
+        return None
+    return val
+
+
+def promptForList(prompt, default=""):
+    val = getInputWithDefault(prompt, default)
+    if type(val) not in (list, tuple):
+        return None
+    return val
+
+
+def isnum(o):
+    return isinstance(o, (int, float))
+
+
+def allnum(l):
+    return not [o for o in l if not isnum(o)]
+
+
+DEBUG = False
+
+
+
+def command(f):
+    """A decorator to wrap a command method or function.
+
+    Calls to the decorated method or function are wrapped by call_command.
+    """
+    # TODO: remove one level of stack trace by not using wraps
+    @wraps(f)
+    def wrapper(*args, **kwds):
+        return call_command(f, args)
+
+    return wrapper
+
+
+def call_command(f, args):
+
+    if DEBUG:
+        return f(*args)
+    try:
+        return f(*args)
+    except TypeError, e:
+        # NOTE: TypeErrors resulting from bugs in the core code will be
+        # erroneously caught here! TODO: check depth of TypeError stack
+        raise TypeError(e.message + '\n\nUSAGE:\n' + f.__doc__)
+    except DiffcalcException, e:
+        # TODO: log and create a new one to shorten stack trace for user
+        raise DiffcalcException(e.message)
diff --git a/script/test/diffcalc (copy)/diffcmd/__init__.py b/script/test/diffcalc (copy)/diffcmd/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/diffcmd/diffcalc_launcher.py b/script/test/diffcalc (copy)/diffcmd/diffcalc_launcher.py
new file mode 100755
index 0000000..0653460
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcmd/diffcalc_launcher.py	
@@ -0,0 +1,86 @@
+#!/usr/bin/python
+
+import argparse
+import subprocess
+import os
+import getpass
+
+DIFFCALC_BIN = os.path.split(os.path.realpath(__file__))[0]
+DIFFCALC_ROOT = os.path.abspath(os.path.join(DIFFCALC_BIN, os.pardir))
+
+MODULE_FOR_MANUALS = '_make_sixcircle_manual'
+
+def main():
+    parser = argparse.ArgumentParser(description='Diffcalc: A diffraction condition calculator of x-ray and neutron crystalography')
+    parser.add_argument('--modules', dest='show_modules', action='store_true',
+                        help='list available modules')
+    parser.add_argument('--python', dest='use_python', action='store_true',
+                        help='run within python rather than ipython')
+    parser.add_argument('--debug', dest='debug', action='store_true',
+                        help='run in debug mode')
+    parser.add_argument('--make-manuals-source', dest='make_manuals', action='store_true',
+                        help='make .rst manual files by running template through sixcircle')
+    parser.add_argument('--non-interactive', dest='non_interactive', action='store_true',
+                        help='do not enter interactive mode after startup')
+    parser.add_argument('module', type=str, nargs='?',
+                        help='the module to startup with')
+    args = parser.parse_args()
+    
+    # Create list of available modules
+    module_names = []
+    for module_path in os.listdir(os.path.join(DIFFCALC_ROOT, 'startup')):
+        if not module_path.startswith('_') and module_path.endswith('.py'):
+            module_names.append(module_path.split('.')[0])
+    module_names.sort()
+    
+    if args.show_modules:
+        print_available_modules(module_names)
+        exit(0)      
+    
+    if not args.make_manuals and not args.module:   
+        print "A module name should be provided. Choose one of:"
+        print_available_modules(module_names)
+        exit(0)
+        
+    if args.make_manuals:
+        if args.module:
+            print "When building the manuals no module should be given"
+            exit(1)
+        args.module = MODULE_FOR_MANUALS
+        
+    if not args.make_manuals and args.module not in module_names:
+        print "The provided argument '%s' is not one of:" % args.module
+        print_available_modules(module_names)
+        exit(1)
+    
+    env = os.environ.copy()
+    
+    if 'PYTHONPATH' not in env:
+        env['PYTHONPATH'] = ''
+    env['PYTHONPATH'] = DIFFCALC_ROOT + ':' + env['PYTHONPATH']
+    
+    diffcmd_start_path = os.path.join(DIFFCALC_ROOT, 'diffcmd', 'start.py')
+    
+    if args.use_python:
+        cmd = 'python'
+    else:  # ipython
+        cmd = 'ipython --no-banner --HistoryManager.hist_file=/tmp/ipython_hist_%s.sqlite' % getpass.getuser()
+    
+    iflag = '' if args.non_interactive else '-i'    
+    cmd = cmd + ' ' + ' '.join([iflag, diffcmd_start_path, args.module, str(args.debug)])
+   
+    print 'Running: ' + cmd
+    rc = subprocess.call(cmd, env=env, shell=True)
+    exit(rc)
+
+ 
+def print_available_modules(module_names):           
+    lines = []
+    for m in sorted(module_names):
+        lines.append('   ' + m)
+    print '\n'.join(lines)
+
+
+if __name__ == '__main__':
+    main()
+# 
diff --git a/script/test/diffcalc (copy)/diffcmd/diffcmd_utils.py b/script/test/diffcalc (copy)/diffcmd/diffcmd_utils.py
new file mode 100644
index 0000000..57ed4aa
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcmd/diffcmd_utils.py	
@@ -0,0 +1,43 @@
+#
+# General utility functions to handle Diffcalc commands
+#
+
+from gda.jython.commands.GeneralCommands import alias
+
+try:
+    import gda
+    GDA = True  
+except ImportError:
+    GDA = False
+
+
+
+def alias_commands(global_namespace_dict):
+    """Alias commands left in global_namespace_dict by previous import from
+    diffcalc.
+
+    This is the equivalent of diffcmd/ipython/magic_commands() for use
+    when IPython is not available
+    """
+    gnd = global_namespace_dict
+    global GLOBAL_NAMESPACE_DICT
+    GLOBAL_NAMESPACE_DICT = gnd
+    print "Aliasing commands"
+    
+    ### Alias commands in namespace ###
+    commands = gnd['hkl_commands_for_help']
+    commands += gnd['ub_commands_for_help']
+    if not GDA:  # TODO: encapsulation issue: this should be done outside this function!
+        commands.append(gnd['pos'])
+        commands.append(gnd['scan'])       
+    aliased_names = []
+
+    for f in commands:
+        # Skip section headers like 'Motion'
+        if not hasattr(f, '__call__'):
+            continue
+        
+        alias(f.__name__)
+        aliased_names.append(f.__name__)
+
+    print "Aliased commands: " + ' '.join(aliased_names) 
diff --git a/script/test/diffcalc (copy)/diffcmd/ipython.py b/script/test/diffcalc (copy)/diffcmd/ipython.py
new file mode 100644
index 0000000..81b4c33
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcmd/ipython.py	
@@ -0,0 +1,302 @@
+import re
+from functools import wraps
+from IPython.core.magic import register_line_magic
+from IPython import get_ipython  # @UnusedImport (used by register_line_magic)
+from diffcalc.gdasupport.scannable.hkl import Hkl
+
+"""
+For wrapping functions:
+
+    In [1]: import diffcmd.ipython
+    
+    In [2]: diffcmd.ipython.GLOBAL_NAMESPACE_DICT = globals()
+    
+    In [3]: from IPython.core.magic import register_line_magic
+    
+    In [4]: from diffcmd.ipython import parse_line
+    
+    In [5]: @register_line_magic
+       ...: @parse_line
+       ...: def check_parser(*args):
+       ...:         return args
+       ...: 
+    
+    In [6]: check_parser
+    Out[6]: <function __main__.check_parser>
+    
+    In [7]: del check_parser
+    
+    In [8]: check_parser
+    Out[8]: ()
+    
+    In [9]: check_parser 1
+    Out[9]: (1,)
+    
+    In [10]: check_parser 1 2
+    Out[10]: (1, 2)
+    
+    In [11]: check_parser 1 2 [3]
+    Out[11]: (1, 2, [3])
+    
+    In [12]: b='bbb'
+    
+    In [13]: check_parser 1 2 [3] b
+    Out[13]: (1, 2, [3], 'bbb')
+
+
+And to create something dynamically from a function:
+
+    In [28]: def f(a, b, c):
+       ....:        ....:     return a, b, c
+       ....: 
+    
+    In [29]: register_line_magic(parse_line(f))
+    Out[29]: <function __main__.f>
+    
+    In [30]: del f
+    
+    In [31]: f 'a' -2 [1 3 -4]
+    Out[31]: ('a', -2, [1, 3, -4])
+
+And from a list of functions:
+
+    In [32]: def one(a):
+       ....:     return a
+       ....: 
+    
+    In [33]: def two(a, b):
+       ....:     return a, b
+       ....: 
+    
+    In [34]: functions = one, two
+    
+    In [35]: del one, two
+    
+    In [36]: for f in functions:
+       ....:     register_line_magic(parse_line(f))
+       ....:     
+    
+    In [37]: one 1
+    Out[37]: 1
+
+    In [39]: two 1 2
+    Out[39]: (1, 2)
+
+And to check if we are running in iPython:
+
+    In [47]: 'get_ipython' in globals()
+    Out[47]: True
+
+def in_ipython():
+     try:
+         get_ipython()
+         return True
+     except NameError:
+         return False
+
+
+"""
+
+
+GLOBAL_NAMESPACE_DICT = {}
+
+MATH_OPERATORS = set(['-', '+', '/', '*'])
+
+# Keep a copy of python's original help as we may remove it later
+if 'help' in __builtins__:   
+    ORIGINAL_PYTHON_HELP = __builtins__['help']
+
+
+COMMA_USAGE_HELP = \
+'''
+|   When calling a function without brackets, whitespace must be used in
+|   place of commas. For example:
+|   
+|      >>> function a b [1 2 3] 'c'
+|      
+|   is equivalent to:
+|   
+|      >>> function(a, b, [1, 2, 3], 'c')
+|      
+'''
+
+
+MATH_OPERATOR_USAGE_HELP = \
+'''
+|    When calling a function without brackets, whitespace is used in place of
+|    commas. Therefore terms which require evaluation must contain no space.
+|    These will fail for example:
+|
+|      >>> function - 1
+|      >>> function a() * 2
+
+|    But this
+
+|       >>> function -1 1-1 +1 a()+1 [-1 0+1 b()] c+1
+|        
+|    is okay and equivalent to:
+|    
+|       >>> function(-1, 0, 1, a() + 1, [-1, 1, b()], c + 1)
+|       
+      
+'''
+
+comma_finder = re.compile(r'''((?:[^,"']|"[^"]*"|'[^']*')+)''')
+space_finder = re.compile(r'''((?:[^ "']|"[^"]*"|'[^']*')+)''')
+hash_finder = re.compile(r'''((?:[^#"']|"[^"]*"|'[^']*')+)''')
+open_square_finder = re.compile(r'''((?:[^["']|"[^"]*"|'[^']*')+)''')
+close_square_finder = re.compile(r'''((?:[^]"']|"[^"]*"|'[^']*')+)''')
+
+def tokenify(s):
+    
+    # Don't accept commas outside strings.
+    # Users are frustrated by not knowing when commas _are_ required.
+    # Making it clear when they are not helps them understand the
+    # difference.
+
+    if ',' in comma_finder.split(s):
+        print COMMA_USAGE_HELP
+        print "(string was: %s)" % s
+        raise SyntaxError('unexpected comma')
+    
+    # ignore comment  
+    hash_split = hash_finder.split(s)
+    if '#' in hash_split:
+        s = '' if hash_split[0] == '#' else hash_split[1]
+    
+    # surround square brackets with spaces to simplify token extraction
+    s = ''.join(' [ ' if e == '[' else e for e in open_square_finder.split(s))
+    s = ''.join(' ] ' if e == ']' else e for e in close_square_finder.split(s))
+    
+    
+    # tokens are now separated by spaces
+    
+    tokens = space_finder.split(s)[1::2]
+    tokens = [tok for tok in tokens if tok != '']
+    return tokens
+
+
+def parse(s, d):
+    s = str(s)
+    tokens = tokenify(s)
+    for tok in tokens:
+        if tok in MATH_OPERATORS:
+            print MATH_OPERATOR_USAGE_HELP
+            raise SyntaxError('could not evaluate: "%s"' % tok)
+    
+    
+    s = ', '.join(tokens)
+
+    s = s.replace('[, ', '[')
+    s = s.replace(',]', ']')
+    s = s.replace(', ]', ']')
+    
+    try:
+        args = eval('[' + s + ']', d)
+    except SyntaxError:
+        raise SyntaxError('could not evaluate: "%s"' % s)
+    return args
+
+def parse_line(f, global_namespace_dict=None):
+    '''A decorator that parses a single string argument into a list of arguments
+    and calls the wrapped function with these.
+    '''
+    if not global_namespace_dict:
+        global_namespace_dict = GLOBAL_NAMESPACE_DICT
+    @wraps(f)
+    def wrapper(line):
+        args = parse(line, global_namespace_dict)
+        return f(*args)
+    return wrapper
+
+
+
+_DEFAULT_HELP = \
+"""
+For help with diffcalc's orientation phase try:
+    
+    >>> help ub
+    
+For help with moving in reciprocal lattice space try:
+
+    >>> help hkl
+    
+For more detailed help try for example:
+
+    >>> help newub
+    
+For help with driving axes or scanning:
+
+    >>> help pos
+    >>> help scan
+    
+For help with regular python try for example:
+
+    >>> help list
+    
+For more detailed help with diffcalc go to:
+
+    https://diffcalc.readthedocs.io
+    
+"""
+
+def magic_commands(global_namespace_dict):
+    """Magic commands left in global_namespace_dict by previous import from
+    diffcalc.
+    
+    Also creates a help command. NOTE that calling this will
+    remove the original commands from the global namespace as otherwise these
+    would shadow the ipython magiced versions.
+    
+    Depends on hkl_commands_for_help & ub_commands_for_help list having been
+    left in the global namespace and assumes there is pos and scan command.
+    """
+    gnd = global_namespace_dict
+    global GLOBAL_NAMESPACE_DICT
+    GLOBAL_NAMESPACE_DICT = gnd
+    
+    ### Magic commands in namespace ###
+    commands = list(gnd['hkl_commands_for_help'])
+    commands += gnd['ub_commands_for_help']
+    commands.append(gnd['pos'])
+    commands.append(gnd['scan'])       
+    command_map = {}
+    for f in commands:
+        # Skip section headers like 'Motion'
+        if not hasattr(f, '__call__'):
+            continue
+        # magic the function and remove from namespace (otherwise it would
+        # shadow the magiced command)
+        register_line_magic(parse_line(f, gnd))
+        del gnd[f.__name__]
+        command_map[f.__name__] = f
+
+    ### Create help function ###
+    #Expects python's original help to be named pythons_help and to be
+    #available in the top-level global namespace (where non-diffcalc
+    #objects may have help called from).        
+    def help(s):  # @ReservedAssignment   
+        """Diffcalc help for iPython
+        """
+        if s == '':
+            print _DEFAULT_HELP
+        elif s == 'hkl':
+            # Use help injected into hkl object
+            print Hkl.dynamic_docstring
+        elif s == 'ub':
+            # Use help injected into ub command
+            print command_map['ub'].__doc__
+        elif s in command_map:
+            print "%s (diffcalc command):" %s
+            print command_map[s].__doc__
+        else:
+            exec('pythons_help(%s)' %s, gnd)
+
+      
+    ### Setup help command ###
+    gnd['pythons_help'] = ORIGINAL_PYTHON_HELP  
+    register_line_magic(help)
+    # Remove builtin help
+    # (otherwise it would shadow magiced command
+    if 'help' in __builtins__:   
+        del __builtins__['help']
diff --git a/script/test/diffcalc (copy)/diffcmd/ipythonmagic.py b/script/test/diffcalc (copy)/diffcmd/ipythonmagic.py
new file mode 100644
index 0000000..6679864
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcmd/ipythonmagic.py	
@@ -0,0 +1,79 @@
+
+import diffcmd.ipython
+from IPython.core.magic import register_line_magic
+from diffcmd.ipython import parse_line
+
+command_map = {}
+    
+_DEFAULT_HELP = """
+For help with diffcalc's orientation phase try:
+    
+    >>> help ub
+    
+For help with moving in reciprocal lattice space try:
+
+    >>> help hkl
+    
+For more detailed help try for example:
+
+    >>> help newub
+    
+For help with driving axes or scanning:
+
+    >>> help pos
+    >>> help scan
+    
+For help with regular python try for example:
+
+    >>> help list
+    
+For more detailed help with diffcalc go to:
+
+    https://diffcalc.readthedocs.io
+    
+"""
+
+# This function should be called with parameter globals()
+def define_commands(dictionary):
+    print "Ipython detected - magicing commands"
+    magiced_names = []
+    commands = hkl_commands_for_help + ub_commands_for_help  # @UndefinedVariable
+    commands += [pos, scan]  # @UndefinedVariable
+    ipython.GLOBAL_NAMESPACE_DICT = dictionary
+    for f in commands:
+        # Skip section headers like 'Motion'
+        if not hasattr(f, '__call__'):
+            continue
+        
+        # magic the function and remove from namespace (otherwise it would
+        # shadow the magiced command)
+        register_line_magic(parse_line(f))
+        del dictionary[f.__name__]
+        command_map[f.__name__] = f
+        magiced_names.append(f.__name__)
+    
+    print "Magiced commands: " + ' '.join(magiced_names) 
+    
+    # because the functions have gone from namespace we need to override
+    pythons_help = __builtins__.help
+    del __builtins__.help
+    
+    register_line_magic(help)
+    del help
+
+def help(s):
+    """Diffcalc help for iPython
+    """
+    if s == '':
+        print _DEFAULT_HELP
+    elif s == 'hkl':
+        # Use help injected into hkl object
+        print hkl.__doc__
+    elif s == 'ub':
+        # Use help injected into ub command
+        print command_map['ub'].__doc__
+    elif s in command_map:
+        print "%s (diffcalc command):" %s
+        print command_map[s].__doc__
+    else:
+        exec('pythons_help(%s)' %s)
diff --git a/script/test/diffcalc (copy)/diffcmd/make_manual.py b/script/test/diffcalc (copy)/diffcmd/make_manual.py
new file mode 100644
index 0000000..a3b77bf
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcmd/make_manual.py	
@@ -0,0 +1,146 @@
+
+
+from StringIO import StringIO
+from IPython import get_ipython
+import sys
+from diffcalc.dc.help import format_commands_for_rst_table
+
+
+TEST_INPUT="""
+Diffcalc's Scannables
+=====================
+
+Please see :ref:`moving-in-hkl-space` and :ref:`scanning-in-hkl-space` for some relevant examples.
+
+To list and show the current positions of your beamline's scannables
+use ``pos`` with no arguments::
+     
+   >>> pos wl
+   
+should do nought, but this should be replaced::
+
+   ==> pos wl 2  
+   
+should do the thing
+
+   ==> abcd
+"""
+
+
+
+def echorun(magic_cmd):
+    print "\n>>> " + str(magic_cmd)
+     
+
+    
+def make_manual(input_file_path,
+                output_file_path,
+                ub_commands_for_help,
+                hkl_commands_for_help):
+    
+    # Read input file (should be .rst file)
+    with open(input_file_path, 'r') as f:
+        input_string = f.read()
+    
+    # Parse input string
+    output_lines = []
+    for lineno, line in enumerate(input_string.split('\n')):
+        process = '==>' in line
+            
+        if process and 'STOP' in line:
+            print "'==> STOP' found on line. STOPPING", lineno + 1
+            return
+        
+        elif process and 'UB_HELP_TABLE' in line:
+            print 'Creating UB help table'
+            output_lines_from_line = format_commands_for_rst_table(
+                '', ub_commands_for_help)
+            
+        elif process and 'HKL_HELP_TABLE' in line:
+            print 'Creating HKL help table'
+            output_lines_from_line = format_commands_for_rst_table(
+                '', hkl_commands_for_help)
+                
+        else:
+            output_lines_from_line = parse_line(
+                line, lineno + 1, input_file_path)
+
+#         print '\n'.join(output_lines_from_line)
+        output_lines.extend(output_lines_from_line)
+    
+    # Write output file
+    if output_file_path:
+        with open(output_file_path, 'w') as f:
+            f.write('\n'.join(output_lines))
+        print "Wrote file:", output_file_path
+#     try:
+#         if output_file_path:
+#             orig_stdout = sys.stdout
+#             f = file(output_file_path, 'w')
+#             sys.stdout = f
+#         
+#         
+#     
+#     finally:
+#         if output_file_path:
+#             sys.stdout = orig_stdout
+#             f.close()
+
+ 
+def parse_line(linein, lineno, filepath):
+    output_lines = []
+    if '==>' in linein:
+        pre, cmd = linein.split('==>')
+        _check_spaces_only(pre, lineno, filepath)
+        cmd = cmd.strip()  # strip whitespace
+        output_lines.append(pre + ">>> " + cmd)
+        result_lines = _capture_magic_command_output(cmd, lineno, filepath)
+
+        
+        # append to output    
+        for line in result_lines:
+            output_lines.append(pre + line)
+    else:
+        output_lines.append(linein)
+    return output_lines
+
+    
+def _check_spaces_only(s, lineno, filepath):
+    for c in s:
+        if c != ' ':
+            raise Exception('Error on line %i of %s :\n text proceeding --> must be '
+                            'spaces only' % (lineno, filepath))
+            
+def _capture_magic_command_output(magic_cmd, lineno, filepath):
+    orig_stdout = sys.stdout
+    result = StringIO()
+    sys.stdout = result
+    
+    def log_error():
+        msg = "Error on line %i of %s evaluating '%s'" % (lineno, filepath, magic_cmd)
+        sys.stderr.write('\n' + '=' * 79 + '\n' + msg + '\n' +'v' * 79 + '\n')
+        return msg
+    
+    try:
+        line_magics = get_ipython().magics_manager.magics['line']
+        magic = magic_cmd.split(' ')[0]
+        if magic not in line_magics:
+            msg = log_error()
+            raise Exception(msg + " ('%s' is not a magic command)" % magic)           
+        get_ipython().magic(magic_cmd)
+    except:
+        log_error()
+        raise
+    finally:
+        sys.stdout = orig_stdout
+
+    result_lines = result.getvalue().split('\n')
+        
+    # trim trailing lines which are whitespace only
+    while result_lines and (result_lines[-1].isspace() or not result_lines[-1]):
+        result_lines.pop()
+        
+    return result_lines
+    
+
+    
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/diffcmd/start.py b/script/test/diffcalc (copy)/diffcmd/start.py
new file mode 100644
index 0000000..faa7b6d
--- /dev/null
+++ b/script/test/diffcalc (copy)/diffcmd/start.py	
@@ -0,0 +1,87 @@
+"""
+start the diffcmd environemt using a script from startup.
+This should normally be run by the main diffcalc.py program.
+
+with diffcalc on PYTHONPATH
+$ ipython -i -m diffcm.diffcmd module_name_string debug_bool
+"""
+from __future__ import absolute_import
+
+import diffcalc
+import diffcalc.settings
+import os
+import sys
+from diffcalc.ub.persistence import UBCalculationJSONPersister
+from diffcalc.util import bold
+import diffcalc.util
+import diffcalc.gdasupport.minigda.command
+DIFFCALC_ROOT = os.path.realpath(diffcalc.__file__).split('diffcalc/__init__.py')[0]
+
+try:
+    __IPYTHON__  # @UndefinedVariable
+    IPYTHON = True
+except NameError:
+    IPYTHON = False
+
+
+module_name = sys.argv[1] #3 if IPYTHON else 1]
+debug = sys.argv[2] == 'True' #4 if IPYTHON else 2])
+
+print
+print bold('-' * 34 + ' DIFFCALC ' + '-' * 35)
+
+# configure persisentence
+DIFFCALC_VAR = os.path.join(os.path.expanduser('~'), '.diffcalc', module_name)
+if not os.path.exists(DIFFCALC_VAR):
+    print "Making diffcalc var folder:'%s'" % DIFFCALC_VAR
+    os.makedirs(DIFFCALC_VAR)
+diffcalc.settings.ubcalc_persister = UBCalculationJSONPersister(DIFFCALC_VAR)
+
+# configure debug
+diffcalc.util.DEBUG = debug
+if debug:
+    print "WARNING: debug mode on; help for command syntax errors disabled."
+
+# import script
+script = os.path.join(DIFFCALC_ROOT, 'startup', module_name) + '.py'
+
+print "Startup script: '%s'" % script    
+namespace = {}
+execfile(script, namespace)
+globals().update(namespace)
+diffcalc.gdasupport.minigda.command.ROOT_NAMESPACE_DICT = dict(namespace)
+print bold('-' * 36 + ' Help ' + '-' * 37)
+print HELP_STRING  # @UndefinedVariable
+if 'LOCAL_MANUAL' in locals():
+    print "Local:  " + LOCAL_MANUAL  # @UndefinedVariable
+print bold('-' * 79)
+print
+
+
+# magic commands if IPython
+if IPYTHON:
+    from diffcmd.ipython import magic_commands
+    magic_commands(globals())
+
+    
+if 'MANUALS_TO_MAKE' in locals():
+    summary_lines = ['Made manuals:']
+    from diffcmd.make_manual import make_manual
+    for source_path in MANUALS_TO_MAKE:  # @UndefinedVariable
+        import diffcalc.ub.ub
+        try:
+            diffcalc.ub.ub.rmub('example')
+        except KeyError:
+            pass
+        target_path = source_path.replace('_template', '')
+        print '@' * 79
+        print "Making manual"
+        print "    Source:", source_path
+        print "    Target:", target_path
+        
+        make_manual(source_path, target_path,
+                    ub_commands_for_help,  # @UndefinedVariable
+                    hkl_commands_for_help)  # @UndefinedVariable
+        summary_lines.append(' - ' + source_path + ' -- > ' + target_path)
+    print '\n'.join(summary_lines)
+    
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/doc/Makefile b/script/test/diffcalc (copy)/doc/Makefile
new file mode 100644
index 0000000..032954a
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/Makefile	
@@ -0,0 +1,193 @@
+# Makefile for documentation
+# This makefile is a modified version of the makefile generated by the sphinx-quickstart command
+
+# set environment for Diamond Light Source
+ifeq ($(CONTEXT),diamond)
+	@echo "Environment variable CONTEXT=diamond, so setting build environment suitable for Diamond Light Source"
+	# get the location of a Python that has Sphinx installed
+	SPHINXBUILD?=$(shell module load python/2.7.2;which sphinx-build)
+	# set http proxy
+	export http_proxy?=http://wwwcache.rl.ac.uk:8080
+	export https_proxy?=https://wwwcache.rl.ac.uk:8080
+endif
+
+# optionally use Sphinx's "-W" options, which converts warnings into errors
+ifeq ($(HALTONWARNING),y)
+	SPHINXEXTRAOPT=-W
+else ifeq ($(HALTONWARNING),Y)
+	SPHINXEXTRAOPT=-W
+else
+	SPHINXEXTRAOPT=
+endif
+
+### <-- start of Makefile contents generated by sphinx-quickstart --> ###
+
+# You can set these variables from the command line.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+PAPER         ?=
+BUILDDIR      ?= build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXEXTRAOPT) $(SPHINXOPTS) source
+
+.PHONY: help helpfull pwd clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest pdfa4 pdfletter pdf all
+
+help:
+	@echo
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html      to make standalone HTML files"
+	@echo "  pdf       to create pdf files for both A4- and Letter-sized paper"
+	@echo "  pdfa4     to create pdf files for A4-sized paper"
+	@echo "  pdfletter to create pdf files for Letter-sized paper"
+	@echo "  all       to build html and pdf"
+	@echo "  clean     to wipe the build directory"
+	@echo
+	@echo "You can use \`make helpfull' to get a full list of targets (not all have been tested)"
+
+helpfull:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+pwd:
+	@echo
+	@echo "*******************************************************************************************************"
+	@echo "Current directory = "`pwd`
+	@echo "*******************************************************************************************************"
+
+clean: pwd
+	-rm -rf $(BUILDDIR)/*
+
+html: pwd
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/GDA.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/GDA.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/GDA"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/GDA"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex: pwd
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf: pwd
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	make -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+### <-- end of Makefile contents generated by sphinx-quickstart --> ###
+
+pdfa4: pwd
+	rm -rf $(BUILDDIR)/latex
+	rm -rf $(BUILDDIR)/pdf-a4
+	make latexpdf PAPER=a4
+	mkdir $(BUILDDIR)/pdf-a4/
+	cp $(BUILDDIR)/latex/*.pdf $(BUILDDIR)/pdf-a4/.
+	@echo
+	@echo "Build finished for A4-sized PDFs. The PDF files are in $(BUILDDIR)/pdf-a4."
+
+pdfletter: pwd
+	rm -rf $(BUILDDIR)/latex
+	rm -rf $(BUILDDIR)/pdf-letter
+	make latexpdf PAPER=letter
+	mkdir $(BUILDDIR)/pdf-letter/
+	cp $(BUILDDIR)/latex/*.pdf $(BUILDDIR)/pdf-letter/.
+	@echo
+	@echo "Build finished for Letter-sized PDFs. The PDF files are in $(BUILDDIR)/pdf-letter."
+
+pdf: pwd pdfa4 pdfletter
+
+all: pwd html pdf
diff --git a/script/test/diffcalc (copy)/doc/docs-build-diffcalc_doc-linux.launch b/script/test/diffcalc (copy)/doc/docs-build-diffcalc_doc-linux.launch
new file mode 100644
index 0000000..0bba525
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/docs-build-diffcalc_doc-linux.launch	
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.ui.externaltools.ProgramLaunchConfigurationType">
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${project}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LAUNCH_CONFIGURATION_BUILD_SCOPE" value="${none}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="/usr/bin/make"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS" value="${string_prompt:the target(s), which can be one or more of &quot;clean html pdfa4 pdfletter pdf all&quot; (all means &quot;html pdf&quot;).:clean all} HALTONWARNING=${string_prompt:treat warnings as errors (and halt the build):y} CONTEXT=${string_prompt:a keyword (typically the name of your organization) which identifies any setup required (can be omitted).:diamond}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY" value="${project_loc:diffcalc}/doc"/>
+</launchConfiguration>
diff --git a/script/test/diffcalc (copy)/doc/references b/script/test/diffcalc (copy)/doc/references
new file mode 100644
index 0000000..a094e55
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/references	
@@ -0,0 +1,22 @@
+
+.. [You1999] H. You. *Angle calculations for a '4S+2D' six-circle diffractometer.*
+   J. Appl. Cryst. (1999). **32**, 614-623. `(pdf link)
+   <http://journals.iucr.org/j/issues/1999/04/00/hn0093/hn0093.pdf>`__.
+  
+.. [Busing1967] W. R. Busing and H. A. Levy. *Angle calculations for 3- and 4-circle X-ray
+   and neutron diffractometers.* Acta Cryst. (1967). **22**, 457-464. `(pdf link)
+   <http://journals.iucr.org/q/issues/1967/04/00/a05492/a05492.pdf>`__.
+  
+.. [Vlieg1993] Martin Lohmeier and Elias Vlieg. *Angle calculations for a six-circle
+   surface x-ray diffractometer.* J. Appl. Cryst. (1993). **26**, 706-716. `(pdf link)
+   <http://journals.iucr.org/j/issues/1993/05/00/la0044/la0044.pdf>`__.
+  
+.. [Vlieg1998] Elias Vlieg. *A (2+3)-type surface diffractometer: mergence of the z-axis and
+   (2+2)-type geometries.* J. Appl. Cryst. (1998). **31**, 198-203. `(pdf link)
+   <http://journals.iucr.org/j/issues/1998/02/00/pe0028/pe0028.pdf>`__.
+  
+.. [Willmott2011] C. M. Schlepütz, S. O. Mariager, S. A. Pauli, R. Feidenhans'l and
+   P. R. Willmott. *Angle calculations for a (2+3)-type diffractometer: focus
+   on area detectors.* J. Appl. Cryst. (2011). **44**, 73-83. `(pdf link)
+   <http://journals.iucr.org/j/issues/2011/01/00/db5088/db5088.pdf>`__.
+   
diff --git a/script/test/diffcalc (copy)/doc/source/ACKS.rst b/script/test/diffcalc (copy)/doc/source/ACKS.rst
new file mode 100644
index 0000000..81fb355
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/ACKS.rst	
@@ -0,0 +1,34 @@
+################
+Acknowledgements
+################
+
+.. toctree::
+   :maxdepth: 2
+   :numbered:
+
+We would like to acknowledge the people who have made a direct impact on the
+Diffcalc project, knowingly or not, in terms of encouragement, suggestions,
+criticism, bug reports, code contributions, and related projects.
+
+Names are ordered alphabetically by surname.
+
+.. If you add new entries, keep the list sorted by surname!
+
+.. acks::
+
+   * Allesandro Bombardi
+   * Mark Booth
+   * W. R. Busing
+   * Steve Collins
+   * Mirian Garcia-Fernandez
+   * H. A. Levy
+   * Martin Lohmier
+   * Chris Nicklin
+   * Elias Vlieg --- writer of DIF software used as a model for Diffcalc
+   * Robert Walton
+   * H. You
+   * Fajin Yuan
+ 
+Thank you!
+
+Rob Walton & Irakli Sikharulidze
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/doc/source/conf.py b/script/test/diffcalc (copy)/doc/source/conf.py
new file mode 100644
index 0000000..fe9ba1d
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/conf.py	
@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+
+#
+# documentation build configuration file, created by
+# sphinx-quickstart on Fri Apr 15 10:03:07 2011.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os, time
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration -----------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.extlinks', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', 'sphinx.ext.imgmath', 'sphinx.ext.ifconfig']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'Diffcalc'
+copyright = u'2017-%s, Diamond Light Source' % time.strftime('%Y')
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '2.1'
+# The full version, including alpha/beta/rc tags.
+release = '2.1'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = []
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#html_theme = 'default'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+# html_theme_options = {
+# 'sidebarbgcolor'  : '#f2f2f2',
+# 'sidebartextcolor': '#444a95',
+# 'sidebarlinkcolor': '#0b0f40',
+# }
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+
+import sphinx_rtd_theme
+
+html_theme = "sphinx_rtd_theme"
+
+html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+html_logo = 'diffcalc_web.png'
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+#html_static_path = ['_static']
+html_static_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+html_show_sourcelink = False
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+html_show_sphinx = False
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# -- Options for LaTeX output --------------------------------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+latex_paper_size = 'a4'
+
+# The font size ('10pt', '11pt' or '12pt').
+#latex_font_size = '10pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+latex_documents = [
+    ('youmanual', 'diffcalc_user_guide.tex', u'Diffcalc User Guide',
+    u'Diamond Light Source', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page
+latex_logo = 'diffcalc_pdf.png'
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output --------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+#man_pages = []
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {}
+
+"""
+ Additional options for Diffcalc
+"""
+
+todo_include_todos = True
+
+extlinks = {
+    'opengda_url' :('http://www.opengda.org/%s', None),
+    }
+
+rst_prolog = """
+.. |DLS| replace:: :abbr:`DLS (Diamond Light Source)`
+"""
diff --git a/script/test/diffcalc (copy)/doc/source/developer/contents.rst b/script/test/diffcalc (copy)/doc/source/developer/contents.rst
new file mode 100644
index 0000000..d52fdd9
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/developer/contents.rst	
@@ -0,0 +1,25 @@
+########################
+Diffcalc Developer Guide
+########################
+
+:Author: Rob Walton
+:Contact: rob.walton (at) diamond (dot) ac (dot) uk 
+:Website: http://www.opengda.org/
+
+.. rubric:: Diffcalc: A diffraction condition calculator for diffractometer control
+
+.. toctree::
+   :maxdepth: 2
+   :numbered:
+
+   intro
+   package
+   quickstart_api
+   development
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/doc/source/developer/development.rst b/script/test/diffcalc (copy)/doc/source/developer/development.rst
new file mode 100644
index 0000000..12b90c6
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/developer/development.rst	
@@ -0,0 +1,24 @@
+Development
+===========
+
+The files are kept here_ on github_. See bootcamp for an introduction to
+using github. To contribute please fork the project. Otherwise you can make
+a read-only clone or export.
+
+Code format should follow pep8 guidelines. PyDev has a good pep8 checker.
+
+To run the tests install nose_, change directory into the test folder and run::
+
+   $ nosetests
+   .......... ...
+   ----------------------------------------------------------------------
+   Ran 3914 tests in 9.584s
+
+   OK (SKIP=15)
+
+
+
+.. _here: https://github.com/DiamondLightSource/diffcalc
+.. _github: https://github.com
+.. _nose: http://nose.readthedocs.org/en/latest/
+.. _pep8: http://www.python.org/dev/peps/pep-0008/
diff --git a/script/test/diffcalc (copy)/doc/source/developer/intro.rst b/script/test/diffcalc (copy)/doc/source/developer/intro.rst
new file mode 100644
index 0000000..a45eae4
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/developer/intro.rst	
@@ -0,0 +1,55 @@
+Introduction
+============
+
+Diffcalc is a diffraction condition calculator used for controlling
+diffractometers within reciprocal lattice space. It performs the same
+task as the ``fourc``, ``sixc``, ``twoc``, ``kappa``, ``psic`` and
+``surf`` macros from SPEC_.
+
+Diffcalc's standard calculation engine is an implementation of
+[You1999]_ . The first versions of Diffcalc were based on
+[Vlieg1993]_ and [Vlieg1998]_ and a 'Vlieg' engine is still
+available. The 'You' engine is more generic and the plan is to remove
+the old 'Vlieg' engine once beamlines have been migrated. New users
+should use the 'You' engine.
+
+The foundations for this type of calculation were laid by by Busing &
+Levi in their classic paper [Busing1967]_. Diffcalc's orientation
+algorithm is taken from this paper. Busing & Levi also provided the
+original definition of the coordinate frames and of the U and B
+matrices used to describe a crystal's orientation and to convert between
+Cartesian and reciprical lattice space.
+
+Geometry plugins are used to adapt the six circle model used
+internally by Diffcalc to apply to other diffractometers. These
+contain a dictionary of the 'missing' angles which Diffcalc uses to
+constrain these angles internally, and a methods to map from external
+angles to Diffcalc angles and visa versa.
+
+Options to use Diffcalc:
+
+- **The User manual next to this developer manual or README file on github.**
+- The :ref:`quickstart-api` section describes how to run up only
+  the core in Python_. This provides a base option for system integration.
+
+Diffcalc will work with Python 2.7 or higher with numpy_, or with
+Jython 2.7 of higher with Jama_.
+
+
+.. [*] The very small 'Willmott' engine currently handles the case for
+       surface diffraction where the surface normal is held vertical
+       [Willmott2011]_.  The 'You' engine handles this case fine, but
+       currently spins nu into an unhelpful quadrant. We hope to
+       remove the need for this engine soon.
+
+
+.. _SPEC: http://www.certif.com/
+.. _Python: http://python.org
+.. _IPython: http://http://ipython.org/
+.. _Jython: http://jython.org
+.. _OpenGDA: http://opengda.org
+.. _numpy: http://numpy.scipy.org/
+.. _Jama:  http://math.nist.gov/javanumerics/jama/
+
+
+.. include:: ../../references
diff --git a/script/test/diffcalc (copy)/doc/source/developer/package.rst b/script/test/diffcalc (copy)/doc/source/developer/package.rst
new file mode 100644
index 0000000..e4d3210
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/developer/package.rst	
@@ -0,0 +1,30 @@
+Project Files & Directories
+===========================
+
+diffcalc
+   The main source package.
+
+test
+   Diffcalcs unit-test package (use Nose_ to run them).
+
+diffcmd
+    A spec-like openGDA emulator.
+
+numjy
+   A *very* minimal implentation of numpy for jython. It supports only what
+   Diffcalc needs.
+   
+doc
+   The documentation is written in reStructuredText and can be compiled into
+   html and pdf using Python's `Sphinx <http://sphinx.pocoo.org>`_. With Sphinx
+   installed use ``make clean all`` from within the user and developer guide
+   folders to build the documentation.
+
+startup
+   Starup scripts called by diffcmd or openGDA to startup diffcalc
+ 
+model
+   Vrml models of diffractometers and a hokey script for animating then and
+   controlling them from diffcalc.
+
+.. _Nose: http://readthedocs.org/docs/nose/en/latest/
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/doc/source/developer/quickstart_api.rst b/script/test/diffcalc (copy)/doc/source/developer/quickstart_api.rst
new file mode 100644
index 0000000..96bb9a2
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/developer/quickstart_api.rst	
@@ -0,0 +1,266 @@
+.. _quickstart-api:
+
+.. warning:: This documentation is out of date. The README and the user doc has been updated recently. For now if you need help with API, please contact me at Diamond. -- Rob Walton
+
+Quick-Start: Python API
+=======================
+
+This section describes how to run up only the core in Python or
+IPython.  This provides an API which could be used to integrate Diffcalc into an
+existing data acquisition system; although the interface described in
+the README would normally provide a better starting point.
+
+For a full description of what Diffcalc does and how to use it please
+see the 'Diffcalc user manual'.
+
+Setup environment
+-----------------
+
+.. include:: quickstart_setup_environment
+
+
+Start
+-----
+
+With Python start the sixcircle_api.py example startup script (notice
+the -i and -m) and call `demo_all()`::
+
+   $ python -i -m startup.api.sixcircle
+   >>> demo_all()
+
+IPython requires::
+
+   $ ipython -i startup/api/sixcircle.py
+   >>> demo_all()
+
+Alternatively start Python or IPython and cut and paste lines from the rest of
+this tutorial.
+
+Configure a diffraction calculator
+----------------------------------
+
+By default some exceptions are handled in a way to make user interaction
+friendlier. Switch this off with::
+
+   >>> import diffcalc.util
+   >>> diffcalc.util.DEBUG = True
+
+To setup a Diffcalc calculator, first configure `diffcalc.settings` module::
+
+	>>> from diffcalc import settings
+	>>> from diffcalc.hkl.you.geometry import SixCircle
+	>>> from diffcalc.hardware import DummyHardwareAdapter
+	>>> settings.hardware = DummyHardwareAdapter(('mu', 'delta', 'gam', 'eta', 'chi', 'phi'))
+	>>> settings.geometry = SixCircle()  # @UndefinedVariable
+
+The hardware adapter is used by Diffcalc to read up the current angle
+settings, wavelength and axes limits. It is primarily used to simplify
+commands for end users. It could be dropped for this API use, but it
+is also used for the important job of checking axes limits while
+choosing solutions.
+
+Geometry plugins are used to adapt the six circle model used
+internally by Diffcalc to apply to other diffractometers. These
+contain a dictionary of the 'missing' angles which Diffcalc internally
+uses to constrain these angles, and a methods to map from
+external angles to Diffcalc angles and visa versa.
+
+
+Calling the API
+---------------
+
+The ``diffcalc.dc.dcyou`` module (and others) read the ``diffcalc.settings`` module when first
+imported. Note that this means that changes to the settings will most likely
+have no effect unless ``diffcalc.dc.dcyou`` is reloaded::
+
+	>>> import diffcalc.dc.dcyou as dc
+	
+This includes the two critical functions::
+
+	def hkl_to_angles(h, k, l, energy=None):
+	    """Convert a given hkl vector to a set of diffractometer angles
+	    
+	    return angle tuple and virtual angles dictionary
+	    """
+	
+	def angles_to_hkl(angle_tuple, energy=None):
+	    """Converts a set of diffractometer angles to an hkl position
+	    
+	    Return hkl tuple and virtual angles dictionary	    
+	    """
+
+``diffcalc.dc.dcyou`` also brings in all the commands from  ``diffcalc.ub.ub``,
+``diffcalc.hardware`` and ``diffcalc.hkl.you.hkl``. That is it includes all the
+commands exposed in the top level namespace when diffcalc is used interactively::
+
+	>>> dir(dc)
+	
+	['__builtins__', '__doc__', '__file__', '__name__', '__package__',
+	'_hardware','_hkl', '_ub', 'addref', 'allhkl', 'angles_to_hkl', 'c2th',
+	'calcub', 'checkub', 'clearref', 'con', 'constraint_manager', 'delref',
+	'diffcalc', 'editref', 'energy_to_wavelength', 'hardware', 'hkl_to_angles',
+	'hklcalc', 'lastub', 'listub', 'loadub', 'newub', 'rmub', 'saveubas', 'setcut',
+	'setlat', 'setmax', 'setmin', 'settings', 'setu', 'setub', 'showref',
+	'swapref', 'trialub', 'ub', 'ub_commands_for_help', 'ubcalc', 'uncon']
+
+This doesn't form the best API to program against though, so it is best to
+use the four modules more directly. The example below assumes you have
+also imported::
+	
+	>>> from diffcalc.ub import ub
+	>>> from diffcalc import hardware
+	>>> from diffcalc.hkl.you import hkl
+
+Getting help
+------------
+
+To get help for the diffcalc angle calculations, the orientation phase, the
+angle calculation phase, and the dummy hardware adapter commands::
+
+   >>> help(dc)
+   >>> help(ub)
+   >>> help(hkl)
+   >>> help(hardware)
+
+
+Orientation
+-----------
+
+To orient the crystal for example (see the user manual for a fuller
+tutorial) first find some reflections::
+    
+   # Create a new ub calculation and set lattice parameters
+   ub.newub('test')
+   ub.setlat('cubic', 1, 1, 1, 90, 90, 90)
+		
+   # Add 1st reflection (demonstrating the hardware adapter)
+   hardware.settings.hardware.wavelength = 1
+   ub.c2th([1, 0, 0])                              # energy from hardware
+   settings.hardware.position = 0, 60, 0, 30, 0, 0 # mu del nu eta chi ph
+   ub.addref([1, 0, 0])                            # energy & pos from hardware
+	
+   # Add 2nd reflection (this time without the hardware adapter)
+   ub.c2th([0, 1, 0], 12.39842)
+   ub.addref([0, 1, 0], [0, 60, 0, 30, 0, 90], 12.39842)
+   
+
+To check the state of the current UB calculation::
+
+   >>> ub.ub()
+
+	UBCALC
+	
+	   name:          test
+	
+	   n_phi:      0.00000   0.00000   1.00000 <- set
+	   n_hkl:     -0.00000   0.00000   1.00000
+	   miscut:     None
+	
+	CRYSTAL
+	
+	   name:         cubic
+	
+	   a, b, c:    1.00000   1.00000   1.00000
+	              90.00000  90.00000  90.00000
+	
+	   B matrix:   6.28319   0.00000   0.00000
+	               0.00000   6.28319   0.00000
+	               0.00000   0.00000   6.28319
+	
+	UB MATRIX
+	
+	   U matrix:   1.00000   0.00000   0.00000
+	               0.00000   1.00000   0.00000
+	               0.00000   0.00000   1.00000
+	
+	   U angle:    0
+	
+	   UB matrix:  6.28319   0.00000   0.00000
+	               0.00000   6.28319   0.00000
+	               0.00000   0.00000   6.28319
+	
+	REFLECTIONS
+	
+	     ENERGY     H     K     L        MU    DELTA      GAM      ETA      CHI      PHI  TAG
+	   1 12.398  1.00  0.00  0.00    0.0000  60.0000   0.0000  30.0000   0.0000   0.0000  
+	   2 12.398  0.00  1.00  0.00    0.0000  60.0000   0.0000  30.0000   0.0000  90.0000  
+	
+And finally to check the reflections were specified acurately::
+
+   >>> dc.checkub()
+   
+       ENERGY     H     K     L    H_COMP   K_COMP   L_COMP     TAG
+   1  12.3984  1.00  0.00  0.00    1.0000   0.0000   0.0000        
+   2  12.3984  0.00  1.00  0.00   -0.0000   1.0000   0.0000 
+
+Motion
+------
+
+Hkl positions and virtual angles can now be read up from angle
+settings (the easy direction!)::
+
+
+	>>> dc.angles_to_hkl((0., 60., 0., 30., 0., 0.)) # energy from hardware
+
+	((1.0, 5.5511151231257827e-17, 0.0),
+	{'alpha': -0.0,
+	 'beta': 3.5083546492674376e-15,
+	 'naz': 0.0,
+	 'psi': 90.0,
+	 'qaz': 90.0,
+	 'tau': 90.0,
+	 'theta': 29.999999999999996})
+
+Before calculating the settings to reach an hkl position (the trickier
+direction) hardware limits must be set and combination of constraints
+chosen. The constraints here result in a four circle like mode with a
+vertical scattering plane and incident angle 'alpha' equal to the exit
+angle 'beta'::
+
+   >>> hkl.con('qaz', 90)
+   !   2 more constraints required
+       qaz: 90.0000
+
+   >>> hkl.con('a_eq_b')
+   !   1 more constraint required
+       qaz: 90.0000
+       a_eq_b
+
+   >>> hkl.con('mu', 0)
+       qaz: 90.0000
+       a_eq_b
+       mu: 0.0000
+
+To check the constraints::
+
+   >>> hkl.con()
+       DET        REF        SAMP
+       ======     ======     ======
+       delta  --> a_eq_b --> mu
+       alpha      eta
+   --> qaz        beta       chi
+       naz        psi        phi
+                             mu_is_nu
+
+       qaz: 90.0000
+       a_eq_b
+       mu: 0.0000
+
+       Type 'help con' for instructions
+
+Limits can be set to help Diffcalc choose a solution::
+
+    >>> hardware.setmin('delta', 0)       # used when choosing solution
+
+Angles and virtual angles are then easily determined for a given hkl reflection::
+
+   >>> dc.hkl_to_angles(1, 0, 0)                        # energy from hardware
+   ((0.0, 60.0, 0.0, 30.0, 0.0, 0.0),
+    {'alpha': -0.0,
+     'beta': 0.0,
+     'naz': 0.0,
+     'psi': 90.0,
+     'qaz': 90.0,
+     'tau': 90.0,
+     'theta': 30.0}
+    )
diff --git a/script/test/diffcalc (copy)/doc/source/developer/quickstart_setup_environment b/script/test/diffcalc (copy)/doc/source/developer/quickstart_setup_environment
new file mode 100644
index 0000000..fe36a74
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/developer/quickstart_setup_environment	
@@ -0,0 +1,25 @@
+
+Change directory to the diffcalc project (python adds the current
+working directory to the path)::
+
+   $ cd diffcalc
+   $ ls
+   COPYING  diffcalc  doc  example  mock.py  mock.pyc  model  numjy  test
+
+If using Python make sure numpy and diffcalc can be imported::
+
+   $ python
+   Python 2.7.2+ (default, Oct  4 2011, 20:06:09) 
+   [GCC 4.6.1] on linux2
+   Type "help", "copyright", "credits" or "license" for more information.
+   >>> import numpy
+   >>> import diffcalc
+
+If using Jython make sure Jama and diffcalc can be imported::
+   
+   $ jython -Dpython.path=<diffcalc_root>:<path_to_Jama>/Jama-1.0.1.jar
+
+   Jython 2.2.1 on java1.5.0_11
+   Type "copyright", "credits" or "license" for more information.
+   >>> import Jama
+   >>> import diffcalc
diff --git a/script/test/diffcalc (copy)/doc/source/diffcalc_pdf.png b/script/test/diffcalc (copy)/doc/source/diffcalc_pdf.png
new file mode 100644
index 0000000..7e08c66
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/diffcalc_pdf.png differ
diff --git a/script/test/diffcalc (copy)/doc/source/diffcalc_web.png b/script/test/diffcalc (copy)/doc/source/diffcalc_web.png
new file mode 100644
index 0000000..d7ddec5
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/diffcalc_web.png differ
diff --git a/script/test/diffcalc (copy)/doc/source/index.rst b/script/test/diffcalc (copy)/doc/source/index.rst
new file mode 100644
index 0000000..b65fbd4
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/index.rst	
@@ -0,0 +1,26 @@
+###################################
+ Diffcalc User and Developer Guide
+###################################
+
+:Author: Rob Walton
+:Contact: rob.walton (at) diamond.ac.uk
+:Web site: https://github.com/DiamondLightSource/diffcalc
+
+.. rubric:: Diffcalc: A Diffraction Condition Calculator for Diffractometer Control
+
+See also the `quickstart guide at github <https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst>`_.
+
+.. toctree::
+   :maxdepth: 2
+   
+   youmanual
+   vliegmanual/contents
+   developer/contents
+   ACKS
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/contents.rst b/script/test/diffcalc (copy)/doc/source/vliegmanual/contents.rst
new file mode 100644
index 0000000..7d60a69
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/vliegmanual/contents.rst	
@@ -0,0 +1,22 @@
+#############################################
+Diffcalc User Guide (Deprecated Vlieg Engine)
+#############################################
+
+:Author: Rob Walton
+:Contact: rob.walton (at) diamond (dot) ac (dot) uk 
+:Website: http://www.opengda.org/
+
+.. rubric:: Diffcalc: A diffraction condition calculator for diffractometer control
+
+.. toctree::
+   :maxdepth: 2
+   :numbered:
+
+   vliegmanual
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/images/fix.png b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/fix.png
new file mode 100644
index 0000000..b4307d4
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/fix.png differ
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.pdf b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.pdf
new file mode 100644
index 0000000..907a254
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.pdf differ
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.png b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.png
new file mode 100755
index 0000000..a1f2d93
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.png differ
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.ppt b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.ppt
new file mode 100755
index 0000000..0af759a
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/sixcircle_gamma_on_arm.ppt differ
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/images/unit_cell.pdf b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/unit_cell.pdf
new file mode 100644
index 0000000..3114c35
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/unit_cell.pdf differ
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/images/unit_cell.png b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/unit_cell.png
new file mode 100644
index 0000000..b431458
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/vliegmanual/images/unit_cell.png differ
diff --git a/script/test/diffcalc (copy)/doc/source/vliegmanual/vliegmanual.rst b/script/test/diffcalc (copy)/doc/source/vliegmanual/vliegmanual.rst
new file mode 100644
index 0000000..4638b3e
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/vliegmanual/vliegmanual.rst	
@@ -0,0 +1,827 @@
+Introduction
+============
+
+.. warning::
+
+   This manual refers to the 'Vlieg' calculation available in Diffcalc I. By
+   default Diffcalc II now uses its 'You' engine. This manual will be updated
+   soon. For now the developer guide shows how the new constraint system works.
+
+This manual assumes that you are running Diffcalc within the external
+framework of the GDA or Minigda and that Diffcalc has been configured
+for the six circle diffractometer pictured here:
+
+.. figure:: images/sixcircle_gamma_on_arm.*
+   :scale: 50
+   :align: center
+
+   Gamma-on-delta six-circle diffractometer, modified from Elias Vlieg
+   & Martin Lohmeier (1993)
+
+Your Diffcalc configuration will have been customised for the geometry
+of your diffractometer and possibly the types of experiment you
+perform. For example: a five-circle diffractometer might be missing
+the Gamma circle above, some six-circle modes and the option to fix
+gamma that would otherwise exist in some modes.
+
+The laboratory, crystal and reciprocal-lattice coordinate frames are
+defined with respect to the beam and to gravity to be (for a cubic crystal):
+
+.. figure:: images/fix.png
+   :align: center
+
+   Laboratory and illustratrive crystal coordinate frames for a cubic crystal
+
+The crystal lattice basis vectors are defined within the Cartesian
+crystal coordinate frame to be:
+
+.. figure:: images/unit_cell.*
+   :align: center
+   :scale: 100
+
+   Unit cell defined in crystal coordinate frame
+
+.. _overview:
+
+Overview
+========
+
+The following assumes that the diffractometer has been properly levelled, aligned with
+the beam and zeroed. See the `SPEC fourc manual <http://www.certif.com/spec_manual/fourc_4_2.html>`__.
+
+Before moving in hkl space you must calculate a UB matrix by
+specifying the crystal's lattice parameters (which define the B
+matrix) and finding two reflections (from which the
+U matrix can be inferred); and, optionally for surface-diffraction
+experiments, determine how the surface of the crystal is oriented with
+respect to the phi axis.
+
+
+Once a UB matrix has been calculated, the diffractometer may be driven
+in hkl coordinates. A valid diffractometer setting maps easily into a
+single hkl value. However for a diffractometer with more than three circles
+there are excess degrees of freedom when calculating a diffractometer
+setting from an hkl value. Diffcalc provides modes for using up
+the excess degrees of freedom.
+
+Diffcalc does not perform scans directly. Instead, scannables that use
+diffcalc to map between reciprocal lattice space and real
+diffractometer settings are scanned using the Gda's (or minigda's)
+generic scan mechanism.
+
+
+Theory
+------
+
+Thanks to Elias Vlieg for sharing his dos based ``DIF`` software that
+Diffcalc has borrowed heavily from. (See also the THANKS.txt file).
+
+See the papers (included in ``docs/ref``):
+
+* Busing & Levi (1966), "Angle Calculations for 3- and 4- Circle X-ray
+  and Neutron Diffractometers", Acta Cryst. 22, 457
+
+* Elias Vlieg & Martin Lohmeier (1993), "Angle Calculations for a Six-Circle
+  Surface X-ray Diffractometer", J. Appl. Cryst. 26, 706-716
+
+Getting Help
+============
+
+There are few commands to remember. If a command is called without
+arguments, Diffcalc will prompt for arguments and provide sensible
+defaults which can be chosen by pressing enter.
+
+The ``helpub`` and ``helphkl`` commands provide help with the crystal
+orientation and hkl movement phases of an experiment respectively::
+      
+    >>> helpub
+    
+          Diffcalc
+          --------
+            helpub  ['command']        - lists all ub commands, or one if command is given
+           helphkl  ['command']        - lists all hkl commands, or one if command is given
+
+          UB State
+          --------
+             newub  'name'             - starts a new ub calculation with no lattice or
+                                         reflection list
+            loadub  'name'             - loads an existing ub calculation: lattice and 
+                                         reflection list
+          saveubas  'name'             - saves the ubcalculation with a new name (other
+                                         changes autosaved)
+                ub                     - shows the complete state of the ub calculation
+
+        UB lattice
+        ----------
+            setlat                     - prompts user to enter lattice parameters (in 
+                                         Angstroms and Deg.)
+            setlat  'name' a           - assumes cubic
+            setlat  'name' a b         - assumes tetragonal
+            setlat  'name' a b c       - assumes ortho
+            setlat  'name' a b c gam   - assumes mon/hex with gam not equal to 90
+            setlat  'name' a b c alpha beta gamma  - arbitrary
+
+        UB surface
+        ----------
+            sigtau  [sigma tau]        - sets sigma and tau
+    
+    UB reflections
+    --------------
+           showref                     - shows full reflection list
+            addref                     - add reflection
+            addref  h k l ['tag']      - add reflection with hardware position and energy
+            addref  h k l (p1,p2...pN) energy ['tag']- add reflection with specified position
+                                                       and energy
+            delref  num                - deletes a reflection (numbered from 1)
+           swapref                     - swaps first two reflections used for calculating U
+           swapref  num1 num2          - swaps two reflections (numbered from 1)
+    
+    UB calculation
+    --------------
+              setu  [((,,),(,,),(,,))] - manually set u matrix
+             setub  ((,,),(,,),(,,))   - manually set ub matrix
+            calcub                     - (re)calculate u matrix from ref1 and ref2
+           checkub                     - show calculated and entered hkl values for reflections
+    
+    >>> helphkl
+    
+          Diffcalc
+          --------
+           helphkl  [command]          - lists all hkl commands, or one if command is given
+            helpub  [command]          - lists all ub commands, or one if command is given
+    
+          Settings
+          --------
+           hklmode  [num]              - changes mode or shows current and available modes 
+                                         and all settings
+          setalpha  [num]              - fixes alpha, or shows all settings if no num given
+          setgamma  [num]              - fixes gamma, or shows all settings if no num given
+         setbetain  [num]              - fixes betain, or shows all settings if no num given
+        setbetaout  [num]              - fixes betaout, or shows all settings if no num given
+        trackalpha  [boolean]          - determines wether alpha parameter will track alpha axis
+        trackgamma  [boolean]          - determines wether gamma parameter will track gamma axis
+          trackphi  [boolean]          - determines wether phi parameter will track phi axis
+      setsectorlim  [omega_high omega_low phi_high phi_low]- sets sector limits
+
+            Motion
+            ------
+               pos   hkl [h k l]       - move diffractometer to hkl, or read hkl position. 
+                                         Use None to hold a value still
+               sim  hkl [h k l]        - simulates moving hkl
+               hkl                     - shows loads of info about current hkl position
+               pos  sixc [alpha, delta, gamma, omega, chi, phi,]- move diffractometer to Eularian
+                                                                  position. Use None to hold a
+                                                                  value still
+               sim  sixc [alpha, delta, gamma, omega, chi, phi,]- simulates moving sixc
+              sixc                     - shows loads of info about current sixc position
+
+
+Diffcalc's Scannables
+=====================
+
+Please see :ref:`moving-in-hkl-space` and :ref:`scanning-in-hkl-space` for some relevant examples.
+
+To list and show the current positions of your beamline's scannables
+use ``pos`` with no arguments::
+     
+   >>> pos
+
+Results in:
+
+**Energy and wavelength scannables**::
+
+    energy    12.3984
+    wl:       1.0000
+
+**Diffractometer scannables**, as a group and in component axes (in
+the real GDA these have limits)::
+
+    sixc:     alpha: 0.0000 delta: 0.0000 gamma: 0.0000 omega: 0.0000 chi: 0.0000 phi: 0.0000 
+    alpha:    0.0000
+    chi:      0.0000
+    delta:    0.0000
+    gamma:    0.0000
+    omega:    0.0000
+    phi:      0.0000
+
+**Dummy counter**, which in this example simply counts at 1hit/s::
+
+    cnt:      0.0000
+
+**Hkl scannable**, as a group and in component::
+
+    hkl:      Error: No UB matrix
+    h:        Error: No UB matrix
+    k:        Error: No UB matrix
+    l:        Error: No UB matrix
+
+**Parameter scannables**, used in some modes, these provide a
+scannable alternative to the series of ``fix`` commands described in
+:ref:`moving-in-hkl-space`.::
+    
+    alpha_par:0.00000
+    azimuth:  ---
+    betain:   ---
+    betaout:  ---
+    gamma_par:0.00000
+    phi_par:  ---
+
+ Note that where a parameter corresponds with a physical
+ diffractometer axis, it can also be set to track that axis
+ directly. See `Tracking axis`_ below.
+
+Crystal orientation
+===================
+
+Before moving in hkl space you must calculate a UB matrix by
+specifying the crystal's lattice parameters (which define the B
+matrix) and finding two reflections (from which the
+U matrix can be inferred); and, optionally for surface-diffraction
+experiments, determine how the surface of the crystal is oriented with
+respect to the phi axis (see :ref:`overview`).
+
+Starting a UB calculation
+-------------------------
+
+A *UB-calculation* contains the description of the crystal-under-test,
+any saved reflections, sigma & tau (both default to 0), and a B & UB
+matrix pair if they have been calculated or manually specified.
+Starting a new UB calculation will clear all of these.
+
+Before starting a UB-calculation, the ``ub`` command used to summarise
+the state of the current UB-calculation, will reflect that no
+UB-calculation has been started::
+
+    >>> ub
+    No UB calculation started.
+    Wavelength: 1.239842
+	Energy: 10.000000
+
+A new UB-calculation calculation may be started and lattice specified
+explicitly::
+    
+    >>> newub 'b16_270608'
+    >>> setlat 'xtal' 3.8401 3.8401 5.43072 90 90 90
+   
+or interactively::
+
+    >>> newub
+    calculation name: b16_270608
+    crystal name: xtal
+           a [1]: 3.8401
+      b [3.8401]: 3.8401
+      c [3.8401]: 5.43072
+      alpha [90]: 90
+       beta [90]: 90
+      gamma [90]: 90
+
+where a,b and c are the lengths of the three unit cell basis vectors
+in Angstroms, and alpha, beta and gamma the typically used angles
+(defined in the figure above) in Degrees.
+
+The ``ub`` command will show the state of the current UB-calculation
+(and the current energy for reference)::
+
+    UBCalc:     b16_270608
+    ======
+      
+    Crystal
+    -------
+    name:          xtal
+
+    lattice:                   a ,b ,c  =  3.84010,  3.84010,  5.43072
+                   alpha, beta , gamma  = 90.00000, 90.00000, 90.00000
+ 
+    reciprocal:             b1, b2, b3  =  1.63620,  1.63620,  1.15697
+                   beta1, beta2, beta3  =  1.57080,  1.57080,  1.57080
+
+    B matrix:      1.6362035642769  -0.0000000000000   -0.000000000000
+                   0.0000000000000   1.6362035642769   -0.000000000000
+                   0.0000000000000   0.0000000000000    1.156970955450
+
+    Reflections
+    -----------
+    energy h    k    l     alpha    delta    gamma    omega    chi      phi       tag
+ 
+    UB matrix
+    ---------
+    none calculated
+
+    Sigma: 0.000000
+    Tau:   0.000000
+    Wavelength: 1.000000
+    Energy:    12.398420
+
+
+Specifying Sigma and Tau for surface diffraction experiments
+------------------------------------------------------------
+Sigma and Tau are used in modes that fix either the beam exit or entry angle with
+respect to the crystal surface, or that keep the surface normal in the horizontal
+laboratory plane. For non surface-diffraction experiments these can
+safely be left at zero.
+
+For surface diffraction experiments, where not only the crystal's
+lattice planes must be oriented appropriately but so must the crystal's
+optical surface, two angles _Tau_ and _Sigma_ define the orientation of
+the surface with respect to the phi axis. Sigma is (minus) the amount of chi axis
+rotation and Tau (minus) the amount of phi axis rotation needed to
+move the surface normal parallel to the omega circle
+axis. These angles are often determined by reflecting a laser from the
+surface of the Crystal onto some thing and moving chi and tau until
+the reflected spot remains stationary with movements of omega.
+
+Use ``sigtau`` with no args to set interactively::
+
+    >>> pos chi -3.1
+    chi:      -3.1000
+    >>> pos phi 10.0
+    phi:      10.0000
+    >>> sigtau
+    sigma, tau = 0.000000, 0.000000
+      chi, phi = -3.100000, 10.000000
+    sigma[  3.1]: 3.1
+      tau[-10.0]: 10.0
+
+Sigma and Tau can also be set explicitly::
+
+    >>>sigtau 0 0
+
+
+Managing reflections
+--------------------
+The normal way to calculate a UB matrix is to find the position of **two**
+reflections with known hkl values. Diffcalc allows many
+reflections to be recorded but currently only uses the first two when
+calculating a UB matrix.
+
+Add reflection at current location
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It is normal to first move to a reflection::
+
+    >>> pos en 10
+    en:       10.0000
+    >>> pos sixc [5.000, 22.790, 0.000, 1.552, 22.400, 14.255]
+    sixc:     alpha: 5.0000 delta: 22.7900 gamma: 0.0000 omega: 1.5520 chi: 22.4000 phi: 14.2550 
+
+
+and then use the ``addref`` command either explicitly::
+      
+    addref  1 0 1.0628 'optional_tag'
+
+or interactively::
+
+    >>> addref
+    h: 1
+    k: 0
+    l: 1.0628
+    current pos[y]: y
+    tag: 'tag_string'
+
+to add a reflection.
+
+Add a reflection manually
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If a reflection cannot be reached but its position is known (or if its
+position has been previously determined), a reflection may be added
+without first moving to it either explicitly::
+
+    >>> addref 0 1 1.0628 [5.000, 22.790, 0.000,4.575, 24.275, 101.320] 'optional_tag'
+
+or interactively::
+
+    >>> addref
+    h: 0
+    k: 1
+    l: 1.0628
+    current pos[y]: n
+      alpha[5.000]: 
+      delta[22.79]: 
+      gamma[0.000]:
+      omega[1.552]: 4.575
+	chi[22.40]: 24.275
+	phi[14.25]: 101.320
+         en[9.998]: 
+	tag: optional_tag2
+
+Edit reflection list
+~~~~~~~~~~~~~~~~~~~~
+
+Use ``showref`` to show the reflection list::
+
+    >>> showref
+	 energy h    k    l     alpha    delta    gamma    omega    chi      phi       tag
+      1  9.999  1.00 0.00 1.06  5.0000   22.7900  0.0000   1.5520   22.4000  14.2550   1st
+      2  9.999  0.00 1.00 1.06  5.0000   22.7900  0.0000   4.5750   24.2750  101.32000 2nd
+
+Use ``swapref`` to swap reflections::
+
+    >>> swapref 1 2
+    Recalculating UB matrix.
+    >>> showref
+	  energy h    k    l     alpha    delta    gamma    omega    chi      phi       tag
+       1  9.999  0.00 1.00 1.06  5.0000   22.7900  0.0000   4.5750   24.2750  101.3200  2nd
+       2  9.999  1.00 0.00 1.06  5.0000   22.7900  0.0000   1.5520   22.4000  14.2550   1st
+
+Use ``delref`` to delete a reflection::
+
+    >>> delref 1
+    >>> showref
+	  energy h    k    l     alpha    delta    gamma    omega    chi      phi       tag
+       1  9.999  1.00 0.00 1.06  5.0000   22.7900  0.0000   1.5520   22.4000  14.2550   1st
+
+Calculating a UB matrix
+-----------------------
+
+Unless a U or UB matrix has been manually specified, a new UB matrix
+will be calculated after the second reflection has been found, or
+whenever one of the first two reflections is changed.
+
+Use the command ``calcub`` to force the UB matrix to be calculated
+from the first two reflections.
+
+If you have misidentified a reflection used for the orientation the
+resulting UB matrix will be incorrect. Always use the ``checkub``
+command to check that the computed values agree with the estimated values::
+
+    >>>checkub
+       energy h    k    l     h_comp k_comp l_comp  tag
+    1  9.9987 1.00 0.00 1.06  1.0000 0.0000 1.0628  1st
+    2  9.9987 0.00 1.00 1.06 -0.0329 1.0114 1.0400  2nd
+
+Notice that the first reflection will always match, but that the
+second will not match exactly. (The system of equations used to
+calculate the U matrix is overdetermined and some information from the
+second reflection is thrown away.)
+
+Manually setting U and UB 
+-------------------------
+
+*To help find the initial reflections* it may be useful to set the U
+matrix manually---to the identity matrix for example. Use the ``setu``
+command to do this. Once set the diffractometer may be driven to the
+ideal location of a reflection and then the actual reflection
+sought. Normally this would be done in the default mode, four-circle-bisecting, (see
+:ref:`moving-in-hkl-space`). In the following example this has been done
+by setting the alpha to 5 and leaving gamma at 0 (it would be normal
+to leave alpha at 0)::
+
+    >>> hklmode 1
+    1) fourc bisecting
+       alpha: 0.0
+       gamma: 0.0
+
+    >>> setalpha 5
+    alpha: 0 --> 5.000000
+    >>> setu
+    row1[1 0 0]:
+    row2[0 1 0]:
+    row3[0 0 1]:
+    >>> sim hkl [1,0,1.0628] # Check it all makes sense
+    sixc would move to:
+       alpha :   5.00000 deg
+       delta :  22.79026 deg
+       gamma :   0.00000 deg
+       omega :   5.82845 deg
+	 chi :  24.57658 deg
+	 phi :   6.14137 deg
+
+       theta : 70702.991919
+      2theta : 23.303705
+	 Bin : 6.969151
+	Bout : 6.969151
+     azimuth : 7.262472
+
+    >>> pos hkl [1,0,1.0628]
+    hkl:      h: 1.00000 k: 0.00000 l: 1.06280
+
+    >>> # scan about to find actual reflection
+
+    >>> addref
+    h[0.0]: 1
+    k[0.0]: 0
+    l[0.0]: 1.0628
+    current pos[y]: y
+    tag: 'ref1'
+    >>> 
+
+
+There is currently no way to refine a manually specified U matrix by
+inferring as much as possible from just one found reflection.
+
+.. _moving-in-hkl-space:
+
+Moving in hkl space
+===================
+
+Once a UB matrix has been calculated, the diffractometer may be driven
+in hkl coordinates. A given diffractometer setting maps easily into a
+single hkl value. However for a diffractometer with more than three circles
+there are excess degrees of freedom when calculating a diffractometer
+setting from an hkl value. Diffcalc provides many for using up
+the excess degrees of freedom.
+
+By default Diffcalc selects four-circle bisecting mode (see below).
+
+Note that to play along with the following ``run`` the file in
+``example/session/sixc_example.py`` to configure the UB-calculation.
+
+
+Modes
+-----
+
+Use the command ``hklmode`` to summarise the state of Diffcalc's angle
+calculator. It shows a list the available modes for your
+diffractometer and the parameters that must be fixed for each, the
+current mode and the current parameter settings::
+     
+    >>> hklmode
+    Available modes:
+     0) fourc fixed-bandlw (alpha, gamma, blw) (Not impl.)
+     1) fourc bisecting (alpha, gamma) 
+     2) fourc incoming  (alpha, gamma, betain) 
+     3) fourc outgoing  (alpha, gamma, betaout) 
+     4) fourc azimuth   (alpha, gamma, azimuth) (Not impl.)
+     5) fourc fixed-phi (alpha, gamma, phi) (Not impl.)
+    10) fivec bisecting (gamma) 
+    11) fivec incoming  (gamma, betain) 
+    12) fivec outgoing  (gamma, betaout) 
+    13) fivec bisecting (alpha) 
+    14) fivec incoming  (alpha, betain) 
+    15) fivec outgoing  (alpha, betaout) 
+    20) zaxis bisecting () 
+    21) zaxis incoming  (betain) 
+    22) zaxiz outgoing  (betaout) 
+
+    Current mode:
+
+    1) fourc bisecting
+    Parameters:
+
+       alpha: 0.0 
+       gamma: 0.0 
+      betain: --- (not relevant in this mode)
+     betaout: --- (not relevant in this mode)
+     azimuth: --- (not relevant in this mode)
+	 phi: --- (not relevant in this mode)
+	 blw: --- (not relevant in this mode)
+
+Note that 'Not impl.' is short for 'not implemented'.  Standby.
+
+Your output may differ. For example:
+
+ - When listed with a typical five-circle diffractometer with no gamma
+   circle: the fourc modes will have no gamma parameter to fix
+   (actually it will have been fixed under the covers to 0), there
+   will be no gamma or alpha parameters to fix in the five circle
+   modes (again, under the covers gamma will have been fixed) and
+   there will be no zaxis modes (as these require six circles, or an
+   actual z-axis diffractometer).
+
+ - When listed with a typical four-circle diffractometer with no alpha
+   or gamma circle, the four-circle modes will appear with no alpha or
+   gamma parameters (again, they are fixed under the covers), and
+   there will be no five circle or zaxis modes.
+
+To change the current mode, call ``hklmode`` with an argument::
+
+    >>> hklmode 2
+    2) fourc incoming
+       alpha: 0.0 
+       gamma: 0.0 
+      betain: ---
+
+(The dashes next to the betain parameter indicate that a parameter
+has not yet been set.)
+
+Mode parameters
+---------------
+
+A parameter can be set using either one of the series of {{{set}}}
+commands, by moving one of the scannables associated with each
+parameter or, where appropriate, by asking that a parameter track an
+axis.
+
+Set commands
+~~~~~~~~~~~~
+Use the series of commands ``set<param_name>`` to set a parameter::
+
+    >>> setalpha 3
+    alpha: 0 --> 3.000000
+    >>> setbetain 5
+    WARNING: The parameter betain is not used in mode 1
+    betain: --- --> 5.000000
+    >>> setalpha    # With no args, the current value is displayed
+    alpha: 3
+    >>> setbetain
+    betain: ---
+
+
+Parameter Scannables
+~~~~~~~~~~~~~~~~~~~~
+
+In most installations there will be a scannable for each parameter. In
+this example installation, the parameters which correspond to physical
+axes have had '_par' appended to their names to prevent clashes. These
+may be used to change a parameter either with the ``pos`` command or
+by using them within a scan (see :ref:`scanning-in-hkl-space`).::
+    
+    >>> pos betain
+    betain:   0.00000
+    >>> pos betain 5
+    betain:   5.00000
+    >>> setbetain
+    betain: 5
+ 
+    >>> pos alpha_par
+    alpha_par:3.00000
+    >>> setalpha
+    alpha: 3
+
+
+Tracking Axis
+~~~~~~~~~~~~~
+Where a parameter matches an axis name, that parameter may be set to
+track that axis::
+
+    >>> pos alpha
+    alpha:    5.0000
+
+    >>> hklmode 1
+    1) fourc bisecting
+       alpha: 0.0
+       gamma: 0.0
+
+    >>> trackalpha
+    alpha: 5
+     
+    >>> pos alpha
+    alpha:    6.0000
+     
+    >>> hklmode 1
+    1) fourc bisecting
+       alpha: 6.0  (tracking physical axis)
+       gamma: 0.0
+
+
+Although convenient, there is a danger with this method that in
+geometries where the axes are built from other axes (such as in a
+kappa geometry), the position of an axis may drift slightly during a
+scan.
+
+Sectors
+-------
+
+When mapping from reciprocal lattice space to a set of diffractometer
+settings, there is normally a choice of solutions for the sample
+orientation. The selected sector mode will determine which solution is
+used. There is currently only one sector mode:
+
+Sector mode: Find first solution within sector limits
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In this sector mode, taken from 'DIF', the first solution found within
+the 'sector limits' is chosen. These are different from the physical
+or software limits on the axes and can be checked/modified using
+``setsectorlim``::
+
+    >>> setsectorlim
+    omega_high[270]:
+     omega_low[-90]:
+      phi_high[180]:
+       phi_low[-180]:
+
+
+The hkl scannable
+-----------------
+Once a UB matrix has been calculated, a mode chosen and parmeters set,
+use the hkl scannable to move to a point in reciprocal lattice space::
+
+    >>> pos hkl [1,0,0]
+    hkl:      h: 1.00000 k: -0.00000 l: -0.00000
+    >>> pos sixc
+    sixc:     alpha: 3.0000 delta: 17.2252 gamma: 4.0000 omega: 7.5046 chi: -24.6257 phi: 4.8026
+    >>> pos hkl
+    hkl:      h: 1.00000 k: -0.00000 l: -0.00000
+    >>> hkl
+    hkl:
+	   h : 1.000000
+	   k : -0.000000
+	   l : -0.000000
+      2theta : 18.582618
+         Bin : -0.387976
+        Bout : -0.387976
+     azimuth : 1.646099
+
+Notice that typing ``hkl`` will also display some virtual angles (such
+as twotheta and Bin), that checking the position with ``pos hkl`` will
+not.
+
+To get this extra information into a scan use the scannable hklverbose
+instead of hkl::
+
+     >>> pos hklverbose [1,0,0]
+     hklverbose:      h: 1.00000 k: -0.00000 l: -0.00000  2theta : 18.582618 Bin : -0.387976
+                      Bout :-0.387976  azimuth : 1.646099
+
+The ``sim`` command will report, without moving the diffractometer,
+where an hkl position would be found::
+
+    >>> sim hkl [1,0,0]
+    sixc would move to:
+       alpha :   3.00000 deg
+       delta :  17.22516 deg
+       gamma :   4.00000 deg
+       omega :   7.50461 deg
+	 chi : -24.62568 deg
+	 phi :   4.80260 deg
+
+       theta : 70702.991919
+      2theta : 18.582618
+	 Bin : -0.387976
+	Bout : -0.387976
+     azimuth : 1.646099
+
+
+
+Moving out of range
+~~~~~~~~~~~~~~~~~~~
+Not every hkl position can be reached::
+
+    >>> pos hkl [10,10,10]
+    Exception: Could not compute delta for this hkl position
+
+The diffractometer scannable (sixc)
+-----------------------------------
+We've seen this before, but it also works with sim::
+
+    gda>>>sim sixc [3, 17.22516, 4, 7.50461,  -24.62568, 4.80260]
+    hkl would move to:
+      h : 1.000000
+      k : 0.000000
+      l : -0.000000
+
+.. _scanning-in-hkl-space:
+
+Scanning in hkl space
+=====================
+
+All scans described below use the same generic scanning mechanism
+provided by the GDA system or by minigda. Here are some examples.
+
+Fixed hkl scans
+---------------
+
+In a 'fixed hkl scan' something (such as energy or Bin) is scanned,
+and at each step hkl is 'moved' to keep the sample and detector
+aligned. Also plonk the diffractometer scannable (sixc) on there with no
+destination to monitor what is actually happening and then
+throw on a detector (cnt) with an exposure time if appropriate::
+
+    >>> #scan scannable_name start stop step [scannable_name [pos or time]]..
+
+    >>> scan en 9 11 .5 hkl [1,0,0] sixc cnt 1
+ 
+    >>> scan en 9 11 .5 hklverbose [1,0,0] sixc cnt 1
+ 
+    >>> scan betain 4 5 .2 hkl [1,0,0] sixc cnt 1
+
+    >>> scan alpha_par 0 10 2 hkl [1,0,0] sixc cnt 1
+
+    >>> trackalpha
+    >>> scan alpha 0 10 2 hkl [1,0,0] sixc cnt 1 # Equivalent to last scan
+
+Scanning hkl
+------------
+
+Hkl, or one component, may also be scanned directly::
+
+    >>> scan h .8 1.2 .1 hklverbose sixc cnt 1
+
+At each step, this will read the current hkl position, modify the h
+component and then move to the resulting vector. There is a danger
+that with this method k and l may drift. To get around this the start,
+stop and step values may also be specified as vectors. So for example::
+
+    >>> scan hkl [1,0,0] [1,.3,0] [1,0.1,0] cnt1
+
+is equivilant to::
+    
+    >>> pos hkl [1,0,0]
+    >>> scan k 0 .3 .1 cnt1
+
+but will not suffer from drifting. This method also allows scans along
+any direction in hkl space to be performed.
+
+Multidimension scans
+--------------------
+
+Two and three dimensional scans::
+
+    >>> scan en 9 11 .5 h .9 1.1 .2 hklverbose sixc cnt 1
+    >>> scan h 1 3 1 k 1 3 1 l 1 3 1 hkl cnt 1
+
+
+
+Good luck --- RobW
diff --git a/script/test/diffcalc (copy)/doc/source/youmanual.rst b/script/test/diffcalc (copy)/doc/source/youmanual.rst
new file mode 100644
index 0000000..a6f1b30
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/youmanual.rst	
@@ -0,0 +1,888 @@
+################################
+Diffcalc User Guide (You Engine)
+################################
+
+.. rubric:: Diffcalc: A diffraction condition calculator for diffractometer control
+
+:Author: Rob Walton
+:Contact: rob.walton (at) diamond (dot) ac (dot) uk 
+:Website: https://github.com/DiamondLightSource/diffcalc
+
+.. toctree::
+   :maxdepth: 2
+   :numbered:
+
+See also the `quickstart guide at github <https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst>`_
+
+Introduction
+============
+
+This manual assumes that you are running Diffcalc within OpenGDA or have started
+it using IPython. It assumes that Diffcalc has been configured for the six
+circle diffractometer pictured here:
+
+.. figure:: youmanual_images/4s_2d_diffractometer.png
+   :scale: 100
+   :align: center
+
+   4s + 2d six-circle diffractometer, from H.You (1999)
+
+Your Diffcalc configuration may have been customised for the geometry of your
+diffractometer and possibly the types of experiment you perform. For example, a
+five-circle diffractometer might be missing the nu circle above.
+
+The laboratory frame is shown above. With all settings at zero as shown the
+crystal  cartesian frame aligns with the laboratory frame. Therefor a cubic
+crystal mounted squarely in a way that the U matrix (defined below) is unitary
+will have h||a||x, k||b||y & l||c||z, crystal and reciprocal-lattice coordinate
+frames are defined with respect to the beam and to gravity to be (for a cubic
+crystal):
+
+Overview
+========
+
+The following assumes that the diffractometer has been properly leveled, aligned
+with the beam and zeroed. See the `SPEC fourc manual
+<http://www.certif.com/spec_manual/fourc_4_2.html>`__.
+
+Before moving in hkl space you must calculate a UB matrix by specifying the
+crystal's lattice parameters (which define the B matrix) and finding two
+reflections (from which the U matrix defining any mismount can be inferred);
+and, optionally for surface-diffraction experiments, determine how the surface
+of the crystal is oriented with respect to the phi axis.
+
+Once a UB matrix has been calculated, the diffractometer may be driven in hkl
+coordinates. A valid diffractometer setting maps easily into a single hkl value.
+However for a diffractometer with more than three circles there are excess
+degrees of freedom when calculating a diffractometer setting from an hkl value.
+Diffcalc provides modes for using up the excess degrees of freedom.
+
+Diffcalc does not perform scans directly. Instead, Scannables that use diffcalc
+to map between reciprocal lattice space and real diffractometer settings are
+scanned using the Gda's (or minigda's) generic scan mechanism.
+
+
+Theory
+------
+
+Thanks to Elias Vlieg for sharing his dos based ``DIF`` software that Diffcalc
+has borrowed heavily from. The version of Diffcalc described here is based on papers by
+pHH. You. [You1999]_ and Busing & Levy [Busing1967]_. (See also the THANKS.txt file.)
+
+Getting Help
+============
+
+There are few commands to remember. If a command is called without
+arguments in some cases Diffcalc will prompt for arguments and provide sensible
+defaults which can be chosen by pressing enter.
+
+
+**Orientation**. The ``helpub`` command lists all commands related with crystal
+orientation and the reference vector (often used with surfaces). See the 
+`Orientation Commands`_ section at the end of this manual::
+
+   >>> help ub
+   ...
+
+
+**HKL movement**. The ``help hkl`` list all commands related to moving in reciprocal-lattice
+space. See the `Motion Commands`_ section at the end of this manual::
+
+   >>> help hkl
+   ...
+
+
+Call help on any command. e.g.::
+
+   >>> help loadub
+   loadub (diffcalc command):
+   loadub 'name' | num -- load an existing ub calculation
+
+Diffcalc's Scannables
+=====================
+
+To list and show the current positions of your beamline's scannables
+use ``pos`` with no arguments::
+
+   >>> pos
+
+Results in:
+
+**Energy and wavelength scannables**::
+
+    energy    12.3984
+    wl:       1.0000
+
+**Diffractometer scannables**, as a group and in component axes (in
+the real GDA these have limits)::
+
+    sixc:     mu: 0.0000 delta: 0.0000 gamma: 0.0000 omega: 0.0000 chi: 0.0000 phi: 0.0000
+    mu:       0.0000
+    chi:      0.0000
+    delta:    0.0000
+    gamma:    0.0000
+    omega:    0.0000
+    phi:      0.0000
+
+**Dummy counter**, which in this example simply counts at 1hit/s::
+
+    ct:      0.0000
+
+**Hkl scannable**, as a group and in component::
+
+    hkl:      Error: No UB matrix
+    h:        Error: No UB matrix
+    k:        Error: No UB matrix
+    l:        Error: No UB matrix
+
+**Parameter scannables**, used in some modes, these provide a
+scannable alternative to the `Motion`_ section. Some constrain of
+these constrain virtual angles::
+
+   alpha:    ---
+   beta:     ---
+   naz:      ---
+   psi:      ---
+   qaz:      ---
+
+and some constrain physical angles::
+
+   phi_con:  ---
+   chi_con:  ---
+   delta_con:---
+   eta_con:  ---
+   gam_con:  ---
+   mu_con:   ---
+
+
+Crystal orientation
+===================
+
+Before moving in hkl space you must calculate a UB matrix by specifying the
+crystal's lattice parameters (which define the B matrix) and finding two
+reflections (from which the U matrix can be inferred); and, optionally for
+surface-diffraction experiments, determine how the surface of the crystal is
+oriented with respect to the phi axis.
+
+Start a new UB calculation
+--------------------------
+
+A *UB calculation* contains the description of the crystal-under-test,
+any saved reflections, reference angle direction, and a B & UB
+matrix pair if they have been calculated or manually specified.
+Starting a new UB calculation will clear all of these.
+
+Before starting a UB-calculation, the ``ub`` command used to summarise
+the state of the current UB-calculation, will reflect that no
+UB-calculation has been started::
+
+    >>> ub
+    <<< No UB calculation started >>>
+
+A new UB-calculation calculation may be started and lattice specified
+explicitly::
+
+    >>> newub 'example'
+    >>> setlat '1Acube' 1 1 1 90 90 90
+
+or interactively::
+
+    >>> newub
+    calculation name: example
+    crystal name: 1Acube
+           a [1]: 1
+           b [1]: 1
+           c [1]: 1
+      alpha [90]: 90
+       beta [90]: 90
+      gamma [90]: 90
+
+where a,b and c are the lengths of the three unit cell basis vectors
+in Angstroms, and alpha, beta and gamma are angles in Degrees.
+
+The ``ub`` command will show the state of the current UB-calculation
+(and the current energy for reference)::
+
+   >>> ub
+   UBCALC
+   
+      name:       example
+   
+      n_phi:      0.00000   0.00000   1.00000 <- set
+   
+   CRYSTAL
+   
+      name:        1Acube
+   
+      a, b, c:    1.00000   1.00000   1.00000
+                 90.00000  90.00000  90.00000
+   
+      B matrix:   6.28319   0.00000   0.00000
+                  0.00000   6.28319   0.00000
+                  0.00000   0.00000   6.28319
+   
+   UB MATRIX
+   
+      <<< none calculated >>>
+   
+   REFLECTIONS
+   
+      <<< none specified >>>
+   
+   CRYSTAL ORIENTATIONS
+   
+   <<< none specified >>>
+
+Load a UB calculation
+---------------------
+
+To load the last used UB-calculation::
+
+   >>> lastub
+   Loading ub calculation: 'mono-Si'
+
+To load a previous UB-calculation::
+
+   >>> listub
+   UB calculations in: /Users/walton/.diffcalc/i16
+
+   0) mono-Si            15 Feb 2017 (22:32)
+   1) i16-32             13 Feb 2017 (18:32)
+
+   >>> loadub 0
+
+Generate a U matrix from two reflections
+----------------------------------------
+
+The normal way to calculate a U matrix is to find the position of **two**
+reflections with known hkl values. Diffcalc allows many reflections to be
+recorded but currently only uses the first two when calculating a UB matrix.
+
+Find U matrix from two reflections::
+
+   >>> pos wl 1
+   wl:        1.0000
+   >>> c2th [0 0 1]
+   59.99999999999999
+
+   >>> pos sixc [0 60 0 30 90 0]
+   sixc:     mu:  0.0000 delta:  60.0000 gam:  0.0000 eta:  30.0000 chi:  90.0000 phi:  0.0000 
+   >>> addref [0 0 1]
+
+   >>> pos sixc [0 90 0 45 45 90]
+   sixc:     mu:  0.0000 delta:  90.0000 gam:  0.0000 eta:  45.0000 chi:  45.0000 phi:  90.0000 
+   >>> addref [0 1 1]
+   Calculating UB matrix.
+
+Check that it looks good::
+
+   >>> checkub
+   
+        ENERGY     H     K     L    H_COMP   K_COMP   L_COMP     TAG
+    1  12.3984  0.00  0.00  1.00    0.0000   0.0000   1.0000        
+    2  12.3984  0.00  1.00  1.00    0.0000   1.0000   1.0000        
+
+Generate a U matrix from one reflection
+---------------------------------------
+
+To estimate based on first reflection only::
+
+   >>> trialub
+   resulting U angle: 0.00000 deg
+   resulting U axis direction: [-1.00000,  0.00000,  0.00000]
+   Recalculating UB matrix from the first reflection only.
+   NOTE: A new UB matrix will not be automatically calculated when the orientation reflections are modified.
+
+Edit reflection list
+--------------------
+
+Use ``showref`` to show the reflection list::
+
+   >>> showref
+        ENERGY     H     K     L        MU    DELTA      GAM      ETA      CHI      PHI  TAG
+      1 12.398  0.00  0.00  1.00    0.0000  60.0000   0.0000  30.0000  90.0000   0.0000  
+      2 12.398  0.00  1.00  1.00    0.0000  90.0000   0.0000  45.0000  45.0000  90.0000  
+
+Use ``swapref`` to swap reflections::
+
+    >>> swapref 1 2
+    Not calculating UB matrix as it has been manually set. Use 'calcub' to explicitly recalculate it.
+    Recalculating UB matrix.
+
+Use ``delref`` to delete a reflection::
+
+    >>> delref 1
+
+Generate a U matrix from two lattice directions
+-----------------------------------------------
+
+Another approach to calculate a U matrix is to provide orientation of **two** crystal lattice
+directions in laboratory frame of reference using ``addorient`` command. The first lattice
+direction will be aligned along the specified in the laboratory frame. The second lattice
+direction will be used to set azimuthal orientation of the crystal in the plane perpendicular
+to the first lattice orientation. Diffcalc allows many lattice directions to be recorded but
+currently uses only the first two when calculating a UB matrix.
+
+Find U matrix from two lattice directions::
+
+   >>> addorient [0 0 1] [0 0 1]
+
+   >>> addorient [1 0 0] [1 1 0]
+   Calculating UB matrix.
+
+Calculate a UB matrix
+---------------------
+
+Unless a U or UB matrix has been manually specified, a new UB matrix will be
+calculated after the second reflection has been found, or whenever one of the
+first two reflections is changed.
+
+Use the command ``calcub`` to force the UB matrix to be calculated from the
+first two reflections. In case of using lattice orientations instead of reflections,
+use command ``orientub`` to force the UB matrix to be calculated from the first two orientations.
+
+If you have misidentified a reflection used for the orientation the
+resulting UB matrix will be incorrect. Always use the ``checkub``command
+to check that the computed reflection indices agree with the estimated values::
+
+   >>> checkub
+   
+        ENERGY     H     K     L    H_COMP   K_COMP   L_COMP     TAG
+    1  12.3984  0.00  1.00  1.00    0.0000   1.0000   1.0000        
+    2  12.3984  0.00  0.00  1.00    0.0000   0.0000   1.0000        
+
+Calculate a U matrix from crystal mismount
+-------------------------------------------
+
+U matrix can be defined from crystal mismount by using a rotation matrix calculated from a provided
+mismount angle and axis. ``setmiscut`` command defines new U matrix by setting it to a rotation matrix
+calculated from the specified angle and axis parameters. ``addmiscut`` command applies the calculated
+rotation matrix to the existing U matrix, i.e. adds extra mismount to the already existing one::
+
+   >>> setmiscut 5 [1 0 0]
+   n_phi: -0.00000  -0.08716   0.99619
+   n_hkl:  0.00000   0.00000   1.00000 <- set
+   normal:
+      angle:  5.00000
+      axis:  1.00000  -0.00000   0.00000
+
+
+Manually specify U matrix
+-------------------------
+
+Set U matrix manually (pretending sample is squarely mounted)::
+
+   >>> setu [[1 0 0] [0 1 0] [0 0 1]]
+   Recalculating UB matrix.
+   NOTE: A new UB matrix will not be automatically calculated when the orientation reflections are modified.
+
+Refining UB matrix from reflection
+----------------------------------
+
+UB matrix elements can be refined to match diffractometer settings and crystal orientation experimentally
+found for a given reflection with the corresponding reflection indices. ``refineub`` command rescales
+crystal unit cell dimensions to match with the found scattering angle value and recalculates mismount
+parameters to update U matrix::
+
+   >>> refineub [1 0 0]
+   current pos[y]: y
+   Unit cell scaling factor:  0.99699
+   Refined crystal lattice:
+      a, b, c:  0.99699   0.99699   0.99699
+                90.00000  90.00000  90.00000
+   
+   Update crystal settings?[y]: y
+   Warning: the old UB calculation has been cleared.
+            Use 'calcub' to recalculate with old reflections or
+            'orientub' to recalculate with old orientations.
+   Miscut parameters:
+         angle:  2.90000
+          axis: -0.00000   1.00000  -0.00000
+   Apply miscut parameters?[y]: y
+      n_phi:  0.67043  -0.00000   0.74198
+      n_hkl:  0.00000   0.00000   1.00000 <- set
+      normal:
+         angle: 42.10000
+         axis:  0.00000   1.00000   0.00000
+
+Set the reference vector
+-------------------------
+
+When performing surface experiments the reference vector should be set normal
+to the surface. It can also be used to define other directions within the crystal
+with which we want to orient the incident or diffracted beam.
+
+By default the reference vector is set parallel to the phi axis. That is,
+along the z-axis of the phi coordinate frame.
+
+The `ub` command shows the current reference vector along with the orientation relative to
+the z-axis, at the top its report (or it can be shown by calling ``setnphi`` or
+``setnhkl'`` with no args)::
+
+ >>> ub
+ ...
+ n_phi:      0.00000   0.00000   1.00000 <- set
+ n_hkl:     -0.00000   0.00000   1.00000
+ normal:     None
+ ...
+
+The ``<- set`` label here indicates that the reference vector is set in the phi
+coordinate frame. In this case, therefore, its direction in the crystal's
+reciprocal lattice space is inferred from the UB matrix.
+
+To set the reference vector in the phi coordinate frame use::
+
+   >>> setnphi [0 0 1]
+   ...
+
+This is useful if the surface normal has be found with a laser or by x-ray
+occlusion. This vector must currently be manually calculated from the sample
+angle settings required to level the surface (sigma and tau commands on the
+way).
+
+To set the reference vector in the crystal's reciprocal lattice space use (this
+is a quick way to determine the surface orientation if the surface is known to
+be cleaved cleanly along a known axis)::
+
+   >>> setnhkl [0 0 1]
+   ...
+
+Motion
+======
+
+Once a UB matrix has been calculated, the diffractometer may be driven
+in hkl coordinates. A given diffractometer setting maps easily into a
+single hkl value. However for a diffractometer with more than three circles
+there are excess degrees of freedom when calculating a diffractometer
+setting from an hkl value. Diffcalc provides many for using up
+the excess degrees of freedom.
+
+By default Diffcalc selects no mode.
+
+Constraining solutions for moving in hkl space
+----------------------------------------------
+
+To get help and see current constraints::
+
+   >>> help con
+   ...
+
+   >>> con
+       DET        REF        SAMP
+       ------     ------     ------
+       delta      a_eq_b     mu
+       gam        alpha      eta
+       qaz        beta       chi
+       naz        psi        phi
+                             mu_is_gam
+   
+   !   3 more constraints required
+   
+       Type 'help con' for instructions
+
+Three constraints can be given: zero or one from the DET and REF columns and the
+remainder from the SAMP column. Not all combinations are currently available.
+Use ``help con`` to see a summary if you run into troubles.
+
+To configure four-circle vertical scattering::
+
+   >>> con gam 0 mu 0 a_eq_b
+       gam  : 0.0000
+       a_eq_b
+       mu   : 0.0000
+
+In the following the *scattering plane* is defined as the plane including the
+scattering vector, or momentum transfer vector, and the incident beam.
+
+**DETECTOR COLUMN:**
+
+- **delta** - physical delta setting (vertical detector motion) *del=0 is equivalent to qaz=0*
+- **gam** - physical gamma setting (horizontal detector motion) *gam=0 is equivalent to qaz=90*
+- **qaz** - azimuthal rotation of scattering vector (about the beam, from horizontal)
+- **naz** - azimuthal rotation of reference vector (about the beam, from horizontal)
+
+**REFERENCE COLUMN:**
+
+- **alpha** - incident angle to surface (if reference is normal to surface)
+- **beta** -  exit angle from surface (if reference is normal to surface)
+- **psi** - azimuthal rotation about scattering vector of reference vector (from scattering plane)
+- **a_eq_b** - bisecting mode with alpha=beta. *Equivalent to psi=90*
+
+**SAMPLE COLUMN:**
+
+- **mu, eta, chi & phi** - physical settings
+- **mu_is_gam** - force mu to follow gamma (results in a 5-circle geometry)
+
+Diffcalc will report two other (un-constrainable) virtual angles:
+
+- **theta** - half of 2theta, the angle through the diffracted beam bends
+- **tau** - longitude of reference vector from scattering vector (in scattering plane)
+
+Example constraint modes
+------------------------
+
+There is sometimes more than one way to get the same effect.
+
+**Vertical four-circle mode**::
+
+   >>> con gam 0 mu 0 a_eq_b   # or equivalently:
+   >>> con qaz 90 mu 0 a_eq_b
+
+   >>> con alpha 1             # replaces a_eq_b
+
+**Horizontal four-circle mode**::
+
+   >>> con del 0 eta 0 alpha 1   # or equivalently:
+   >>> con qaz 0 mu 0 alpha 1
+
+**Surface vertical mode**::
+
+   >>> con naz 90 mu 0 alpha 1
+
+**Surface horizontal mode**::
+
+   >>> con naz 0 eta 0 alpha 1
+
+**Z-axis mode (surface horizontal)**::
+
+   >>> con chi (-sigma) phi (-tau) alpha 1
+
+where sigma and tau are the offsets required in chi and phi to bring the surface
+normal parallel to eta. Alpha will determine mu directly leaving eta to orient
+the planes. Or::
+
+   >>> con naz 0 phi 0 alpha 1  # or any another sample angle
+
+**Z-axis mode (surface vertical)**::
+
+   >>> con naz 0 phi 0 alpha 1  # or any another sample angle
+
+Changing constrained values
+---------------------------
+
+Once constraints are chosen constrained values may be changed directly::
+
+   >>> con mu 10
+       gam  : 0.0000
+       a_eq_b
+       mu   : 10.0000
+
+or via the associated scannable::
+
+   >>> pos mu_con 10
+   mu_con:   10.00000
+
+Configuring limits and cuts
+---------------------------
+
+Diffcalc maintains its own limits on axes. These limits will be used when
+choosing solutions. If more than one detector solution is exists Diffcalc will
+ask you to reduce the the limits until there is only one. However if more than
+one solution for the sample settings is available it will choose one base on
+heuristics.
+
+Use the ``hardware`` command to see the current limits and cuts::
+
+   >>> hardware
+                  mu           (cut: -180.0)
+               delta           (cut: -180.0)
+                 gam           (cut: -180.0)
+                 eta           (cut: -180.0)
+                 chi           (cut: -180.0)
+                 phi           (cut:    0.0)
+   Note: When auto sector/transforms are used,
+          cuts are applied before checking limits.
+
+To set the limits::
+
+   >>> setmin delta -1
+   >>> setmax delta 145
+
+To set a cut::
+
+   >>> setcut phi -180
+
+This causes requests to move phi to be between the configured -180 and +360
+degress above this. i.e. it might dive to -10 degrees rather than 350.
+
+
+Moving in hkl space
+-------------------
+
+Configure a mode, e.g. four-circle vertical::
+
+   >>> con gam 0 mu 0 a_eq_b
+       gam  : 0.0000
+       a_eq_b
+       mu   : 0.0000
+
+Simulate moving to a reflection::
+
+   >>> sim hkl [0 1 1]
+   sixc would move to:
+        mu :    0.0000
+     delta :   90.0000
+       gam :    0.0000
+       eta :   45.0000
+       chi :   45.0000
+       phi :   90.0000
+   
+     alpha :   30.0000
+      beta :   30.0000
+       naz :   35.2644
+       psi :   90.0000
+       qaz :   90.0000
+       tau :   45.0000
+     theta :   45.0000
+
+Move to reflection::
+
+   >>> pos hkl [0 1 1]
+   hkl:      h: 0.00000 k: 1.00000 l: 1.00000 
+
+   >>> pos sixc
+   sixc:     mu:  0.0000 delta:  90.0000 gam:  0.0000 eta:  45.0000 chi:  45.0000 phi:  90.0000 
+
+Simulate moving to a location::
+
+   >>> pos sixc [0 60 0 30 90 0]
+   sixc:     mu:  0.0000 delta:  60.0000 gam:  0.0000 eta:  30.0000 chi:  90.0000 phi:  0.0000 
+
+Scanning in hkl space
+=====================
+
+All scans described below use the same generic scanning mechanism
+provided by the GDA system or by minigda. Here are some examples.
+
+Fixed hkl scans
+---------------
+
+In a 'fixed hkl scan' something (such as energy or Bin) is scanned,
+and at each step hkl is 'moved' to keep the sample and detector
+aligned. Also plonk the diffractometer scannable (sixc) on there with no
+destination to monitor what is actually happening and then
+throw on a detector (ct) with an exposure time if appropriate::
+
+    >>> #scan scannable_name start stop step [scannable_name [pos or time]]..
+
+    >>> scan en 9 11 .5 hkl [1 0 0] sixc ct 1
+
+    >>> scan en 9 11 .5 hklverbose [1 0 0] sixc ct 1
+
+    >>> scan betain 4 5 .2 hkl [1 0 0] sixc ct 1
+
+    >>> scan alpha_par 0 10 2 hkl [1 0 0] sixc ct 1
+
+Scanning hkl
+------------
+
+Hkl, or one component, may also be scanned directly::
+
+    >>> scan h .8 1.2 .1 hklverbose sixc ct 1
+
+At each step, this will read the current hkl position, modify the h
+component and then move to the resulting vector. There is a danger
+that with this method k and l may drift. To get around this the start,
+stop and step values may also be specified as vectors. So for example::
+
+    >>> scan hkl [1 0 0] [1 .3 0] [1 0.1 0] ct1
+
+is equivilant to::
+
+    >>> pos hkl [1 0 0]
+    >>> scan k 0 .3 .1 ct1
+
+but will not suffer from drifting. This method also allows scans along
+any direction in hkl space to be performed.
+
+Multidimension scans
+--------------------
+
+Two and three dimensional scans::
+
+    >>> scan en 9 11 .5 h .9 1.1 .2 hklverbose sixc ct 1
+    >>> scan h 1 3 1 k 1 3 1 l 1 3 1 hkl ct 1
+
+Commands
+========
+
+Orientation Commands
+--------------------
+
++-----------------------------+---------------------------------------------------+
+| **STATE**                                                                       |
++-----------------------------+---------------------------------------------------+
+| **-- newub** {'name'}       | start a new ub calculation name                   |
++-----------------------------+---------------------------------------------------+
+| **-- loadub** 'name' | num  | load an existing ub calculation                   |
++-----------------------------+---------------------------------------------------+
+| **-- lastub**               | load the last used ub calculation                 |
++-----------------------------+---------------------------------------------------+
+| **-- listub**               | list the ub calculations available to load        |
++-----------------------------+---------------------------------------------------+
+| **-- rmub** 'name'|num      | remove existing ub calculation                    |
++-----------------------------+---------------------------------------------------+
+| **-- saveubas** 'name'      | save the ub calculation with a new name           |
++-----------------------------+---------------------------------------------------+
+| **LATTICE**                                                                     |
++-----------------------------+---------------------------------------------------+
+| **-- setlat**               | interactively enter lattice parameters (Angstroms |
+|                             | and Deg)                                          |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a        | assumes cubic                                     |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b      | assumes tetragonal                                |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b c    | assumes ortho                                     |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b c    | assumes mon/hex with gam not equal to 90          |
+| gamma                       |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- setlat** name a b c    | arbitrary                                         |
+| alpha beta gamma            |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- c2th** [h k l]         | calculate two-theta angle for reflection          |
++-----------------------------+---------------------------------------------------+
+| **-- hklangle** [h1 k1 l1]  | calculate angle between [h1 k1 l1] and [h2 k2 l2] |
+| [h2 k2 l2]                  | crystal planes                                    |
++-----------------------------+---------------------------------------------------+
+| **REFERENCE (SURFACE)**                                                         |
++-----------------------------+---------------------------------------------------+
+| **-- setnphi** {[x y z]}    | sets or displays n_phi reference                  |
++-----------------------------+---------------------------------------------------+
+| **-- setnhkl** {[h k l]}    | sets or displays n_hkl reference                  |
++-----------------------------+---------------------------------------------------+
+| **REFLECTIONS**                                                                 |
++-----------------------------+---------------------------------------------------+
+| **-- showref**              | shows full reflection list                        |
++-----------------------------+---------------------------------------------------+
+| **-- addref**               | add reflection interactively                      |
++-----------------------------+---------------------------------------------------+
+| **-- addref** [h k l]       | add reflection with current position and energy   |
+| {'tag'}                     |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- addref** [h k l] (p1,  | add arbitrary reflection                          |
+| .., pN) energy {'tag'}      |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- editref** num          | interactively edit a reflection                   |
++-----------------------------+---------------------------------------------------+
+| **-- delref** num           | deletes a reflection (numbered from 1)            |
++-----------------------------+---------------------------------------------------+
+| **-- clearref**             | deletes all the reflections                       |
++-----------------------------+---------------------------------------------------+
+| **-- swapref**              | swaps first two reflections used for calculating  |
+|                             | U matrix                                          |
++-----------------------------+---------------------------------------------------+
+| **-- swapref** num1 num2    | swaps two reflections (numbered from 1)           |
++-----------------------------+---------------------------------------------------+
+| **CRYSTAL ORIENTATIONS**                                                        |
++-----------------------------+---------------------------------------------------+
+| **-- showorient**           | shows full list of crystal orientations           |
++-----------------------------+---------------------------------------------------+
+| **-- addorient**            | add crystal orientation interactively             |
++-----------------------------+---------------------------------------------------+
+| **-- addorient** [h k l]    | add crystal orientation in laboratory frame       |
+| [x y z] {'tag'}             |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- editorient** num       | interactively edit a crystal orientation          |
++-----------------------------+---------------------------------------------------+
+| **-- delorient** num        | deletes a crystal orientation (numbered from 1)   |
++-----------------------------+---------------------------------------------------+
+| **-- clearorient**          | deletes all the crystal orientations              |
++-----------------------------+---------------------------------------------------+
+| **-- swaporient**           | swaps first two crystal orientations used for     |
+|                             | calculating U matrix                              |
++-----------------------------+---------------------------------------------------+
+| **-- swaporient** num1 num2 | swaps two crystal orientations (numbered from 1)  |
++-----------------------------+---------------------------------------------------+
+| **UB MATRIX**                                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- checkub**              | show calculated and entered hkl values for        |
+|                             | reflections                                       |
++-----------------------------+---------------------------------------------------+
+| **-- setu**                 | manually set u matrix                             |
+| {[[..][..][..]]}            |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- setub**                | manually set ub matrix                            |
+| {[[..][..][..]]}            |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- calcub**               | (re)calculate u matrix from ref1 and ref2         |
++-----------------------------+---------------------------------------------------+
+| **-- trialub**              | (re)calculate u matrix from ref1 only (check      |
+|                             | carefully)                                        |
++-----------------------------+---------------------------------------------------+
+| **-- refineub** {[h k l]}   | refine unit cell dimensions and U matrix to match |
+| {pos}                       | diffractometer angles for a given hkl value       |
++-----------------------------+---------------------------------------------------+
+| **-- addmiscut** angle      | apply miscut to U matrix using a specified miscut |
+| {[x y z]}                   | angle in degrees and a rotation axis              |
+|                             | (default: [0 1 0])                                |
++-----------------------------+---------------------------------------------------+
+| **-- setmiscut** angle      | manually set U matrix using a specified miscut    |
+| {[x y z]}                   | angle in degrees and a rotation axis              |
+|                             | (default: [0 1 0])                                |
++-----------------------------+---------------------------------------------------+
+
+Motion commands
+---------------
+
++-----------------------------+---------------------------------------------------+
+| **CONSTRAINTS**                                                                 |
++-----------------------------+---------------------------------------------------+
+| **-- con**                  | list available constraints and values             |
++-----------------------------+---------------------------------------------------+
+| **-- con** <name> {val}     | constrains and optionally sets one constraint     |
++-----------------------------+---------------------------------------------------+
+| **-- con** <name> {val}     | clears and then fully constrains                  |
+| <name> {val} <name> {val}   |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- uncon** <name>         | remove constraint                                 |
++-----------------------------+---------------------------------------------------+
+| **HKL**                                                                         |
++-----------------------------+---------------------------------------------------+
+| **-- allhkl** [h k l]       | print all hkl solutions ignoring limits           |
++-----------------------------+---------------------------------------------------+
+| **HARDWARE**                                                                    |
++-----------------------------+---------------------------------------------------+
+| **-- hardware**             | show diffcalc limits and cuts                     |
++-----------------------------+---------------------------------------------------+
+| **-- setcut** {name {val}}  | sets cut angle                                    |
++-----------------------------+---------------------------------------------------+
+| **-- setmin** {axis {val}}  | set lower limits used by auto sector code (None   |
+|                             | to clear)                                         |
++-----------------------------+---------------------------------------------------+
+| **-- setmax** {name {val}}  | sets upper limits used by auto sector code (None  |
+|                             | to clear)                                         |
++-----------------------------+---------------------------------------------------+
+| **MOTION**                                                                      |
++-----------------------------+---------------------------------------------------+
+| **-- sim** hkl scn          | simulates moving scannable (not all)              |
++-----------------------------+---------------------------------------------------+
+| **-- sixc**                 | show Eularian position                            |
++-----------------------------+---------------------------------------------------+
+| **-- pos** sixc [mu, delta, | move to Eularian position(None holds an axis      |
+| gam, eta, chi, phi]         | still)                                            |
++-----------------------------+---------------------------------------------------+
+| **-- sim** sixc [mu, delta, | simulate move to Eulerian positionsixc            |
+| gam, eta, chi, phi]         |                                                   |
++-----------------------------+---------------------------------------------------+
+| **-- hkl**                  | show hkl position                                 |
++-----------------------------+---------------------------------------------------+
+| **-- pos** hkl [h k l]      | move to hkl position                              |
++-----------------------------+---------------------------------------------------+
+| **-- pos** {h | k | l} val  | move h, k or l to val                             |
++-----------------------------+---------------------------------------------------+
+| **-- sim** hkl [h k l]      | simulate move to hkl position                     |
++-----------------------------+---------------------------------------------------+
+
+Good luck --- RobW
+
+References
+==========
+
+.. [You1999] H. You. *Angle calculations for a '4S+2D' six-circle diffractometer.*
+   J. Appl. Cryst. (1999). **32**, 614-623. `(pdf link)
+   <http://journals.iucr.org/j/issues/1999/04/00/hn0093/hn0093.pdf>`__.
+.. [Busing1967] W. R. Busing and H. A. Levy. *Angle calculations for 3- and 4-circle X-ray
+   and neutron diffractometers.* Acta Cryst. (1967). **22**, 457-464. `(pdf link)
+   <http://journals.iucr.org/q/issues/1967/04/00/a05492/a05492.pdf>`__.
diff --git a/script/test/diffcalc (copy)/doc/source/youmanual_images/4s_2d_diffractometer.png b/script/test/diffcalc (copy)/doc/source/youmanual_images/4s_2d_diffractometer.png
new file mode 100644
index 0000000..5216255
Binary files /dev/null and b/script/test/diffcalc (copy)/doc/source/youmanual_images/4s_2d_diffractometer.png differ
diff --git a/script/test/diffcalc (copy)/doc/source/youmanual_template.rst b/script/test/diffcalc (copy)/doc/source/youmanual_template.rst
new file mode 100644
index 0000000..1b32fff
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/source/youmanual_template.rst	
@@ -0,0 +1,565 @@
+################################
+Diffcalc User Guide (You Engine)
+################################
+
+.. rubric:: Diffcalc: A diffraction condition calculator for diffractometer control
+
+:Author: Rob Walton
+:Contact: rob.walton (at) diamond (dot) ac (dot) uk 
+:Website: https://github.com/DiamondLightSource/diffcalc
+
+.. toctree::
+   :maxdepth: 2
+   :numbered:
+
+See also the `quickstart guide at github <https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst>`_
+
+Introduction
+============
+
+This manual assumes that you are running Diffcalc within OpenGDA or have started
+it using IPython. It assumes that Diffcalc has been configured for the six
+circle diffractometer pictured here:
+
+.. figure:: youmanual_images/4s_2d_diffractometer.png
+   :scale: 100
+   :align: center
+
+   4s + 2d six-circle diffractometer, from H.You (1999)
+
+Your Diffcalc configuration may have been customised for the geometry of your
+diffractometer and possibly the types of experiment you perform. For example, a
+five-circle diffractometer might be missing the nu circle above.
+
+The laboratory frame is shown above. With all settings at zero as shown the
+crystal  cartesian frame aligns with the laboratory frame. Therefor a cubic
+crystal mounted squarely in a way that the U matrix (defined below) is unitary
+will have h||a||x, k||b||y & l||c||z, crystal and reciprocal-lattice coordinate
+frames are defined with respect to the beam and to gravity to be (for a cubic
+crystal):
+
+Overview
+========
+
+The following assumes that the diffractometer has been properly leveled, aligned
+with the beam and zeroed. See the `SPEC fourc manual
+<http://www.certif.com/spec_manual/fourc_4_2.html>`__.
+
+Before moving in hkl space you must calculate a UB matrix by specifying the
+crystal's lattice parameters (which define the B matrix) and finding two
+reflections (from which the U matrix defining any mismount can be inferred);
+and, optionally for surface-diffraction experiments, determine how the surface
+of the crystal is oriented with respect to the phi axis.
+
+Once a UB matrix has been calculated, the diffractometer may be driven in hkl
+coordinates. A valid diffractometer setting maps easily into a single hkl value.
+However for a diffractometer with more than three circles there are excess
+degrees of freedom when calculating a diffractometer setting from an hkl value.
+Diffcalc provides modes for using up the excess degrees of freedom.
+
+Diffcalc does not perform scans directly. Instead, Scannables that use diffcalc
+to map between reciprocal lattice space and real diffractometer settings are
+scanned using the Gda's (or minigda's) generic scan mechanism.
+
+
+Theory
+------
+
+Thanks to Elias Vlieg for sharing his dos based ``DIF`` software that Diffcalc
+has borrowed heavily from. The version of Diffcalc described here is based on papers by
+pHH. You. [You1999]_ and Busing & Levy [Busing1967]_. (See also the THANKS.txt file.)
+
+Getting Help
+============
+
+There are few commands to remember. If a command is called without
+arguments in some cases Diffcalc will prompt for arguments and provide sensible
+defaults which can be chosen by pressing enter.
+
+
+**Orientation**. The ``helpub`` command lists all commands related with crystal
+orientation and the reference vector (often used with surfaces). See the 
+`Orientation Commands`_ section at the end of this manual::
+
+   >>> help ub
+   ...
+
+
+**HKL movement**. The ``help hkl`` list all commands related to moving in reciprocal-lattice
+space. See the `Motion Commands`_ section at the end of this manual::
+
+   >>> help hkl
+   ...
+
+
+Call help on any command. e.g.::
+
+   ==> help loadub
+
+Diffcalc's Scannables
+=====================
+
+To list and show the current positions of your beamline's scannables
+use ``pos`` with no arguments::
+
+   >>> pos
+
+Results in:
+
+**Energy and wavelength scannables**::
+
+    energy    12.3984
+    wl:       1.0000
+
+**Diffractometer scannables**, as a group and in component axes (in
+the real GDA these have limits)::
+
+    sixc:     mu: 0.0000 delta: 0.0000 gamma: 0.0000 omega: 0.0000 chi: 0.0000 phi: 0.0000
+    mu:       0.0000
+    chi:      0.0000
+    delta:    0.0000
+    gamma:    0.0000
+    omega:    0.0000
+    phi:      0.0000
+
+**Dummy counter**, which in this example simply counts at 1hit/s::
+
+    ct:      0.0000
+
+**Hkl scannable**, as a group and in component::
+
+    hkl:      Error: No UB matrix
+    h:        Error: No UB matrix
+    k:        Error: No UB matrix
+    l:        Error: No UB matrix
+
+**Parameter scannables**, used in some modes, these provide a
+scannable alternative to the `Motion`_ section. Some constrain of
+these constrain virtual angles::
+
+   alpha:    ---
+   beta:     ---
+   naz:      ---
+   psi:      ---
+   qaz:      ---
+
+and some constrain physical angles::
+
+   phi_con:  ---
+   chi_con:  ---
+   delta_con:---
+   eta_con:  ---
+   gam_con:  ---
+   mu_con:   ---
+
+
+Crystal orientation
+===================
+
+Before moving in hkl space you must calculate a UB matrix by specifying the
+crystal's lattice parameters (which define the B matrix) and finding two
+reflections (from which the U matrix can be inferred); and, optionally for
+surface-diffraction experiments, determine how the surface of the crystal is
+oriented with respect to the phi axis.
+
+Start a new UB calculation
+--------------------------
+
+A *UB calculation* contains the description of the crystal-under-test,
+any saved reflections, reference angle direction, and a B & UB
+matrix pair if they have been calculated or manually specified.
+Starting a new UB calculation will clear all of these.
+
+Before starting a UB-calculation, the ``ub`` command used to summarise
+the state of the current UB-calculation, will reflect that no
+UB-calculation has been started::
+
+    ==> ub
+
+A new UB-calculation calculation may be started and lattice specified
+explicitly::
+
+    ==> newub 'example'
+    ==> setlat '1Acube' 1 1 1 90 90 90
+
+or interactively::
+
+    >>> newub
+    calculation name: example
+    crystal name: 1Acube
+           a [1]: 1
+           b [1]: 1
+           c [1]: 1
+      alpha [90]: 90
+       beta [90]: 90
+      gamma [90]: 90
+
+where a,b and c are the lengths of the three unit cell basis vectors
+in Angstroms, and alpha, beta and gamma are angles in Degrees.
+
+The ``ub`` command will show the state of the current UB-calculation
+(and the current energy for reference)::
+
+   ==> ub
+
+Load a UB calculation
+---------------------
+
+To load the last used UB-calculation::
+
+   >>> lastub
+   Loading ub calculation: 'mono-Si'
+
+To load a previous UB-calculation::
+
+   >>> listub
+   UB calculations in: /Users/walton/.diffcalc/i16
+
+   0) mono-Si            15 Feb 2017 (22:32)
+   1) i16-32             13 Feb 2017 (18:32)
+
+   >>> loadub 0
+
+Generate a U matrix from two reflections
+----------------------------------------
+
+The normal way to calculate a U matrix is to find the position of **two**
+reflections with known hkl values. Diffcalc allows many reflections to be
+recorded but currently only uses the first two when calculating a UB matrix.
+
+Find U matrix from two reflections::
+
+   ==> pos wl 1
+   ==> c2th [0 0 1]
+   59.99999999999999
+
+   ==> pos sixc [0 60 0 30 90 0]
+   ==> addref [0 0 1]
+
+   ==> pos sixc [0 90 0 45 45 90]
+   ==> addref [0 1 1]
+
+Check that it looks good::
+
+   ==> checkub
+
+Generate a U matrix from one reflection
+---------------------------------------
+
+To estimate based on first reflection only::
+
+   ==> trialub
+
+Manually specify U matrix
+-------------------------
+
+Set U matrix manually (pretending sample is squarely mounted)::
+
+   ==> setu [[1 0 0] [0 1 0] [0 0 1]]
+
+Edit reflection list
+--------------------
+
+Use ``showref`` to show the reflection list::
+
+   ==> showref
+
+Use ``swapref`` to swap reflections::
+
+    ==> swapref 1 2
+    Recalculating UB matrix.
+
+Use ``delref`` to delete a reflection::
+
+    >>> delref 1
+
+Calculate a UB matrix
+---------------------
+
+Unless a U or UB matrix has been manually specified, a new UB matrix will be
+calculated after the second reflection has been found, or whenever one of the
+first two reflections is changed.
+
+Use the command ``calcub`` to force the UB matrix to be calculated from the
+first two reflections.
+
+If you have misidentified a reflection used for the orientation the
+resulting UB matrix will be incorrect. Always use the ``checkub``
+command to check that the computed values agree with the estimated values::
+
+    ==> checkub
+
+Set the reference vector
+-------------------------
+
+When performing surface experiments the reference vector should be set normal
+to the surface. It can also be used to define other directions within the crystal
+with which we want to orient the incident or diffracted beam.
+
+By default the reference vector is set parallel to the phi axis. That is,
+along the z-axis of the phi coordinate frame.
+
+The `ub` command shows the current reference vector, along with any inferred
+miscut, at the top its report (or it can be shown by calling ``setnphi`` or
+``setnhkl'`` with no args)::
+
+ >>> ub
+ ...
+ n_phi:      0.00000   0.00000   1.00000 <- set
+ n_hkl:     -0.00000   0.00000   1.00000
+ miscut:     None
+ ...
+
+The ``<- set`` label here indicates that the reference vector is set in the phi
+coordinate frame. In this case, therefor, its direction in the crystal's
+reciprocal lattice space is inferred from the UB matrix.
+
+To set the reference vector in the phi coordinate frame use::
+
+   >>> setnphi [0 0 1]
+   ...
+
+This is useful if the surface normal has be found with a laser or by x-ray
+occlusion. This vector must currently be manually calculated from the sample
+angle settings required to level the surface (sigma and tau commands on the
+way).
+
+To set the reference vector in the crystal's reciprocal lattice space use (this
+is a quick way to determine the surface orientation if the surface is known to
+be cleaved cleanly along a known axis)::
+
+   >>> setnhkl [0 0 1] ...
+
+Motion
+======
+
+Once a UB matrix has been calculated, the diffractometer may be driven
+in hkl coordinates. A given diffractometer setting maps easily into a
+single hkl value. However for a diffractometer with more than three circles
+there are excess degrees of freedom when calculating a diffractometer
+setting from an hkl value. Diffcalc provides many for using up
+the excess degrees of freedom.
+
+By default Diffcalc selects no mode.
+
+Constraining solutions for moving in hkl space
+----------------------------------------------
+
+To get help and see current constraints::
+
+   >>> help con
+   ...
+
+   ==> con
+
+Three constraints can be given: zero or one from the DET and REF columns and the
+remainder from the SAMP column. Not all combinations are currently available.
+Use ``help con`` to see a summary if you run into troubles.
+
+To configure four-circle vertical scattering::
+
+   ==> con gam 0 mu 0 a_eq_b
+
+In the following the *scattering plane* is defined as the plane including the
+scattering vector, or momentum transfer vector, and the incident beam.
+
+**DETECTOR COLUMN:**
+
+- **delta** - physical delta setting (vertical detector motion) *del=0 is equivalent to qaz=0*
+- **gam** - physical gamma setting (horizontal detector motion) *gam=0 is equivalent to qaz=90*
+- **qaz** - azimuthal rotation of scattering vector (about the beam, from horizontal)
+- **naz** - azimuthal rotation of reference vector (about the beam, from horizontal)
+
+**REFERENCE COLUMN:**
+
+- **alpha** - incident angle to surface (if reference is normal to surface)
+- **beta** -  exit angle from surface (if reference is normal to surface)
+- **psi** - azimuthal rotation about scattering vector of reference vector (from scattering plane)
+- **a_eq_b** - bisecting mode with alpha=beta. *Equivalent to psi=90*
+
+**SAMPLE COLUMN:**
+
+- **mu, eta, chi & phi** - physical settings
+- **mu_is_gam** - force mu to follow gamma (results in a 5-circle geometry)
+
+Diffcalc will report two other (un-constrainable) virtual angles:
+
+- **theta** - half of 2theta, the angle through the diffracted beam bends
+- **tau** - longitude of reference vector from scattering vector (in scattering plane)
+
+Example constraint modes
+------------------------
+
+There is sometimes more than one way to get the same effect.
+
+**Vertical four-circle mode**::
+
+   >>> con gam 0 mu 0 a_eq_b   # or equivalently:
+   >>> con qaz 90 mu 0 a_eq_b
+
+   >>> con alpha 1             # replaces a_eq_b
+
+**Horizontal four-circle mode**::
+
+   >>> con del 0 eta 0 alpha 1   # or equivalently:
+   >>> con qaz 0 mu 0 alpha 1
+
+**Surface vertical mode**::
+
+   >>> con naz 90 mu 0 alpha 1
+
+**Surface horizontal mode**::
+
+   >>> con naz 0 eta 0 alpha 1
+
+**Z-axis mode (surface horizontal)**::
+
+   >>> con chi (-sigma) phi (-tau) alpha 1
+
+where sigma and tau are the offsets required in chi and phi to bring the surface
+normal parallel to eta. Alpha will determine mu directly leaving eta to orient
+the planes. Or::
+
+   >>> con naz 0 phi 0 alpha 1  # or any another sample angle
+
+**Z-axis mode (surface vertical)**::
+
+   >>> con naz 0 phi 0 alpha 1  # or any another sample angle
+
+Changing constrained values
+---------------------------
+
+Once constraints are chosen constrained values may be changed directly::
+
+   ==> con mu 10
+
+or via the associated scannable::
+
+   ==> pos mu_con 10
+
+Configuring limits and cuts
+---------------------------
+
+Diffcalc maintains its own limits on axes. These limits will be used when
+choosing solutions. If more than one detector solution is exists Diffcalc will
+ask you to reduce the the limits until there is only one. However if more than
+one solution for the sample settings is available it will choose one base on
+heuristics.
+
+Use the ``hardware`` command to see the current limits and cuts::
+
+   ==> hardware
+
+To set the limits::
+
+   ==> setmin delta -1
+   ==> setmax delta 145
+
+To set a cut::
+
+   ==> setcut phi -180
+
+This causes requests to move phi to be between the configured -180 and +360
+degress above this. i.e. it might dive to -10 degrees rather than 350.
+
+
+Moving in hkl space
+-------------------
+
+Configure a mode, e.g. four-circle vertical::
+
+   ==> con gam 0 mu 0 a_eq_b
+
+Simulate moving to a reflection::
+
+   ==> sim hkl [0 1 1]
+
+Move to reflection::
+
+   ==> pos hkl [0 1 1]
+
+   ==> pos sixc
+
+Simulate moving to a location::
+
+   ==> pos sixc [0 60 0 30 90 0]
+
+Scanning in hkl space
+=====================
+
+All scans described below use the same generic scanning mechanism
+provided by the GDA system or by minigda. Here are some examples.
+
+Fixed hkl scans
+---------------
+
+In a 'fixed hkl scan' something (such as energy or Bin) is scanned,
+and at each step hkl is 'moved' to keep the sample and detector
+aligned. Also plonk the diffractometer scannable (sixc) on there with no
+destination to monitor what is actually happening and then
+throw on a detector (ct) with an exposure time if appropriate::
+
+    >>> #scan scannable_name start stop step [scannable_name [pos or time]]..
+
+    >>> scan en 9 11 .5 hkl [1 0 0] sixc ct 1
+
+    >>> scan en 9 11 .5 hklverbose [1 0 0] sixc ct 1
+
+    >>> scan betain 4 5 .2 hkl [1 0 0] sixc ct 1
+
+    >>> scan alpha_par 0 10 2 hkl [1 0 0] sixc ct 1
+
+Scanning hkl
+------------
+
+Hkl, or one component, may also be scanned directly::
+
+    >>> scan h .8 1.2 .1 hklverbose sixc ct 1
+
+At each step, this will read the current hkl position, modify the h
+component and then move to the resulting vector. There is a danger
+that with this method k and l may drift. To get around this the start,
+stop and step values may also be specified as vectors. So for example::
+
+    >>> scan hkl [1 0 0] [1 .3 0] [1 0.1 0] ct1
+
+is equivilant to::
+
+    >>> pos hkl [1 0 0]
+    >>> scan k 0 .3 .1 ct1
+
+but will not suffer from drifting. This method also allows scans along
+any direction in hkl space to be performed.
+
+Multidimension scans
+--------------------
+
+Two and three dimensional scans::
+
+    >>> scan en 9 11 .5 h .9 1.1 .2 hklverbose sixc ct 1
+    >>> scan h 1 3 1 k 1 3 1 l 1 3 1 hkl ct 1
+
+Commands
+========
+
+Orientation Commands
+--------------------
+
+==> UB_HELP_TABLE
+
+Motion commands
+---------------
+
+==> HKL_HELP_TABLE
+
+Good luck --- RobW
+
+References
+==========
+
+.. [You1999] H. You. *Angle calculations for a '4S+2D' six-circle diffractometer.*
+   J. Appl. Cryst. (1999). **32**, 614-623. `(pdf link)
+   <http://journals.iucr.org/j/issues/1999/04/00/hn0093/hn0093.pdf>`__.
+.. [Busing1967] W. R. Busing and H. A. Levy. *Angle calculations for 3- and 4-circle X-ray
+   and neutron diffractometers.* Acta Cryst. (1967). **22**, 457-464. `(pdf link)
+   <http://journals.iucr.org/q/issues/1967/04/00/a05492/a05492.pdf>`__.
diff --git a/script/test/diffcalc (copy)/doc/tmp/constraints.txt b/script/test/diffcalc (copy)/doc/tmp/constraints.txt
new file mode 100644
index 0000000..5c64bf2
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/tmp/constraints.txt	
@@ -0,0 +1,47 @@
+Take a six circle diffractometer with angles:
+
+delta, nu, mu, eta, chi, phi
+
+and virtual angles:
+
+qaz, naz, psi, alpha, beta.
+
+Many combinations of these can be constrained:
+
+
+constrain
+>>> con nu
+>>> con psi
+>>> con mu
+>>> con nu mu a_eq_b
+
+real angles are always constrained to there last set position. If they are too far from here
+an error will result.
+
+>>> pos nu 0 (moves, parameter tracks last set value (actually checks it when hkl moved))
+>>> pos psi 90 (does not move, sets parameter in diffcalc)
+>>> pos mu 0 (moves)
+>>> pos hkl [1 0 0] (moves based on last set nu, psi, mu)
+>>> pos betain --> Exception, not constrained
+
+moving a virtual angle simply sets it to efftec the next hkl move
+
+Here we need onlu con, uncon and pos.
+
+......
+
+However it would be nice to be able to pos betain for example and have it change
+betain while staying on the same reflection. This might be enabled by locking the
+the current hkl position. It would be trick to make this work with the physical angles though.
+
+>>> lock hkl
+>>> pos psi 90 (moves immediately)
+>>> scan psi 0 90 1 (scans, moving immediately)
+>>> pos mu 0 (does not move immediately) (could work by listening to target positions, and triggering move when complete)
+>>> pos c(mu) moves
+>>> pos mu_c moves
+
+Only one thing would be varyable at a time unless they are put in a CoordinatedMotionGroup,
+which would be hard for the real motors)
+
+
diff --git a/script/test/diffcalc (copy)/doc/tmp/extensions_to_yous_paper.wxm b/script/test/diffcalc (copy)/doc/tmp/extensions_to_yous_paper.wxm
new file mode 100644
index 0000000..1e866bf
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/tmp/extensions_to_yous_paper.wxm	
@@ -0,0 +1,525 @@
+/* [wxMaxima batch file version 1] [ DO NOT EDIT BY HAND! ]*/
+/* [ Created with wxMaxima version 11.08.0 ] */
+
+/* [wxMaxima: input   start ] */
+Rx:matrix([1,0,0],[0, cos(theta), -sin(theta)],[0, sin(theta), cos(theta)])$
+Ry:matrix([cos(theta), 0, sin(theta)], [0, 1, 0], [-sin(theta), 0, cos(theta)])$
+Rz:matrix([cos(theta), -sin(theta), 0], [sin(theta), cos(theta), 0], [0, 0, 1])$
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+Equation 5:
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+PHI:subst(-phi, theta, Rz);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+CHI:subst(chi, theta, Ry);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+ETA:subst(-eta, theta, Rz);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+MU:subst(mu, theta, Rx);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+Generic V:
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+V:matrix([v11, v12, v13], [v21, v22, v23], [v31, v32, v33]);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: section start ]
+When one sample-orienting angle is given
+   [wxMaxima: section end   ] */
+
+/* [wxMaxima: subsect start ]
+For mu fixed
+   [wxMaxima: subsect end   ] */
+
+/* [wxMaxima: input   start ] */
+eq34:ETA.CHI.PHI;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq34_chi0:subst(0, chi, eq34);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*phi* with chi <> 0
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigsimp((eq34[3,2]=V[3,2])/(eq34[3,1]=V[3,1])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+show that with phi with v31 == 0 and v12 <> 0, no special case is needed when using atan2
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+solve(cos(phi)=0, phi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+atan2(1234,0);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+show that with phi with v32 == 0 and v31 <> 0, no special case is needed when using atan2
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+solve(sin(phi)=0, phi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+atan2(0,1234);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*eta* with chi <> 0 
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigsimp((-eq34[2,3]=V[2,3]) / (eq34[1, 3]=V[1,3])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+eta with v23 == 0 and v13 == 0 (phi||eta degeneracy because chi == 0)
+Then see equation for phi+eta above
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: comment start ]
+*chi*
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigsimp(sqrt((eq34[3,1]=V[3,1])^2+(eq34[3,2]=V[3,2])^2)/(eq34[3,3]=V[3,3]));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*phi + eta* with chi == 0
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigrat((eq34_chi0[1,2]=V[1,2])/(eq1:eq34_chi0[1,1]=V[1,1])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: subsect start ]
+For phi fixed
+   [wxMaxima: subsect end   ] */
+
+/* [wxMaxima: input   start ] */
+eq36:MU.ETA.CHI;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq36_eta90:subst(%pi/2, eta, eq36);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*eta*
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigsimp((eq36[1,2]=V[1,2])/sqrt((eq36[2,2]=V[2,2])^2+(eq36[3,2]=V[3,2])^2));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*mu* with eta <> +-90
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigsimp((eq36[3,2]=V[3,2])/(eq36[2,2]=V[2,2])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*chi* with eta <> +-90
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigsimp((eq36[1,3]=V[1,3])/(eq36[1,1]=V[1,1])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*chi + mu* with eta == +-90
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigrat((eq36_eta90[2,3]=V[2,3])/(eq36_eta90[2,1]=V[2,1])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: subsect start ]
+For eta or chi fixed
+   [wxMaxima: subsect end   ] */
+
+/* [wxMaxima: input   start ] */
+eq38:MU.ETA.CHI.PHI;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*chi* (eq. 39) given eta, and eta <> +-90 (with eta == +-90 chi||mu)
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+(eq38[1,3]=V[1,3])/cos(eta);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: comment start ]
+*eta* given chi, and chi <> 0 (with chi == 0 phi||eta)
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+(eq38[1,3]=V[1,3])/sin(chi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*mu* given that chi and eta have been given or calclulated respecitively
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+top:(eq38[3,3]=V[3,3])*sin(eta)*sin(chi) + (eq38[2,3]=V[2,3])*cos(chi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+bot:-(eq38[3,3]=V[3,3])*cos(chi)+(eq38[2,3]=V[2,3])*sin(eta)*sin(chi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+factor(top);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+factor(bot);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+trigsimp(top/bot);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*phi - mu* when phi || mu because chi == +-90, eta == 0 or eta == 180
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+phi_mu_parallel:subst(0, eta, subst(%pi/2, chi, eq38));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+trigreduce(trigrat((phi_mu_parallel[2,1]=V[2,1])/(phi_mu_parallel[2,2]=V[2,2])));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: section start ]
+Two sample angles given
+   [wxMaxima: section end   ] */
+
+/* [wxMaxima: input   start ] */
+THETA:subst(-theta, theta, Rz);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+PSI:subst(psi, theta, Rx);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+F:subst(xi, theta, Ry);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: section start ]
+psi, mu, eta given
+   [wxMaxima: section end   ] */
+
+/* [wxMaxima: input   start ] */
+eq49:transpose(PHI).transpose(CHI).transpose(ETA).transpose(MU).F;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*chi*
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: comment start ]
+using the linear combination identity
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+comb_idenity:sqrt(A^2+B^2)*sin(x+omega);
+omega:atan(B/A);
+A*sin(x)+B*cos(x)=comb_idenity;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+a:-sin(eta)*cos(mu)$
+b:-sin(mu)$
+V32=a*sin(chi)+b*cos(chi);
+V32=subst(b, B, subst(a, A, comb_idenity));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+asin(%/(sqrt(sin(mu)^2+sin(eta)^2*cos(mu)^2))), triginverses=all;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*xi and phi*
+
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+top:factor(eq49[3,1]*cos(xi)+eq49[3,3]*sin(xi));
+bot:factor(eq49[3,1]*sin(xi)-eq49[3,3]*cos(xi));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+factor(top/bot);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+When mu=-90 and eta = 0, used to for a surface normal vertical mode
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+eq49_vert:subst(-%pi/2, mu, subst(0, eta, eq49));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+(eq49_vert[2,2]=V[2,2]) / (eq49_vert[1,2]=V[1,2]);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: subsect start ]
+mu, phi, qaz (for three circle on i10 and i06, not in paper )
+   [wxMaxima: subsect end   ] */
+
+/* [wxMaxima: input   start ] */
+thisV:transpose(MU).F.THETA;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+Nphi:matrix([n11, n12, n13], [n21, n22, n23], [n31, n32, n33]);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq:ETA.CHI.PHI.Nphi.transpose(PSI);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*chi*
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: comment start ]
+using the linear combination identity
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+comb_idenity:sqrt(A^2+B^2)*sin(x+omega);
+omega:atan(B/A);
+A*sin(x)+B*cos(x)=comb_idenity;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+on V31:
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+a:-1*(n21*sin(phi)+n11*cos(phi))$
+b:n31$
+V31=a*sin(chi)+b*cos(chi);
+V31=subst(b, B, subst(a, A, comb_idenity));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+asin(%/sqrt((-n21*sin(phi)-n11*cos(phi))^2+n31^2)), triginverses=all;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+*xi and phi*
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+top:factor(eq49[3,1]*cos(xi)+eq49[3,3]*sin(xi));
+bot:factor(eq49[3,1]*sin(xi)-eq49[3,3]*cos(xi));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+factor(top/bot);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+solve();
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: section start ]
+Fixed mu, chi, psi (probably with mu=chi=0) (not in paper)
+   [wxMaxima: section end   ] */
+
+/* [wxMaxima: input   start ] */
+Vcalulated:Nphi.transpose(PSI).transpose(THETA);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+thisV:transpose(PHI).transpose(CHI).transpose(ETA).transpose(MU).F;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+v:thisVvert:subst(0, chi, subst(0, mu, thisV));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+acos(thisVvert[3,3]=V[3,3]), triginverses=all;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+top:(v[1,2]=V[1,2])*cos(phi) + (v[2,2]=V[2,2])*sin(phi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+bot:(v[1,2]=V[1,2])*sin(phi) - (v[2,2]=V[2,2])*cos(phi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+factor(top);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+factor(bot);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+trigsimp(top/bot);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: title   start ]
+5.5 subset with eta=chi=0 & phi set
+   [wxMaxima: title   end   ] */
+
+/* [wxMaxima: input   start ] */
+matrix([cos(theta)*sin(qaz)], [-sin(theta)], [cos(theta)*cos(qaz)]);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+h_phi:matrix([h1], [h2], [h3]);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+Z:MU.ETA.CHI.PHI;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq68yterm:-sin(theta) = ((Z.h_phi))[2][1];
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+expands(%);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq68_chi_eta_0:subst(0, chi, subst(0, eta, Z.h_phi));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq68_chi_eta_0_yterm:-sin(theta)=eq68_chi_eta_0[2];
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+subst(0, chi, subst(0, eta, eq68yterm));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+a;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+ratsubst(a, -h3, eq68_chi_eta_0_yterm);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+a:-h3;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+b:-h1*sin(phi) +h2*cos(phi);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+c:-sin(theta);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+ratsubst(cc, c, ratsubst(bb, b, ratsubst(aa, a, eq68_chi_eta_0_yterm)));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+arcsin(c/sqrt(a^2+b^2)) - arctan(b, a);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+eq68_chi_eta_0[1] /eq68_chi_eta_0[2];
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+without chi=eta=0
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+eq68yterm:-sin(theta) = ((Z.h_phi))[2][1];
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+expand(eq68yterm);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+solve for mu unknown
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+c:-sin(theta);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+a:sin(chi)*h2*sin(phi) + sin(chi)*h1*cos(phi) - cos(chi)*h3;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+b: -cos(chi)*sin(eta)*h2*sin(phi) -cos(eta)*h1*sin(phi)  +cos(eta)*h2*cos(phi) -cos(chi)*sin(eta)*h1*cos(phi) - sin(chi)*sin(eta)*h3;
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+expand(subst(a, aa, subst(b, bb, -sin(theta)=aa*sin(mu) + bb*cos(mu))));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+Check a and b expand to produce original (Okay)
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+expand(eq68yterm);
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: comment start ]
+Check against special case above (Okay)
+   [wxMaxima: comment end   ] */
+
+/* [wxMaxima: input   start ] */
+subst(0, chi, subst(0, eta, a));
+/* [wxMaxima: input   end   ] */
+
+/* [wxMaxima: input   start ] */
+subst(0, chi, subst(0, eta, b));
+/* [wxMaxima: input   end   ] */
+
+/* Maxima can't load/batch files which end with a comment! */
+"Created with wxMaxima"$
diff --git a/script/test/diffcalc (copy)/doc/tmp/i16_non_diffcalc_manual.txt b/script/test/diffcalc (copy)/doc/tmp/i16_non_diffcalc_manual.txt
new file mode 100644
index 0000000..16aa9d6
--- /dev/null
+++ b/script/test/diffcalc (copy)/doc/tmp/i16_non_diffcalc_manual.txt	
@@ -0,0 +1,71 @@
+Creating a UB Matrix
+There are three euler modes:
+
+=bisecting: eta and delta are fixed, phi and chi are not fixed.
+=fixed phi: phi and 2theta are fixed, eta and chi are not fixed.
+=fixed psi: Not used for creating a UB matrix .
+First creat a reflection file to store the reflections data using:
+
+reffile('name')
+
+Set the crystal lattice:
+
+latt([a]) assumes cubic
+latt([a,b]) assumes tetragonal
+latt([a,b,c]) assumes orthorhombic
+latt([a,b,c,gam]) assumes monclinic/hexagonal gam different from 90.
+latt([a,b,c,alp,bet,gam])
+
+Use:
+
+c2th([h k l])
+
+to calculate the 2 theta position for the hkl for example:
+
+c2th([0 0 2])
+
+Then use the following to move the diffractometer to the correct positions:
+
+pos delta c2th([0 0 2]) eta c2th([0 0 2])/2
+
+You can now scan eta, chi, and delta to optomise the peak intensity using the following scans for example:
+
+scancn eta 0.01 40 w 0.2 t 1
+
+scancn chi 0.01 40 w 0.2 t 1
+
+scancn delta 0.01 40 w 0.2 t 1
+
+A few iterations may be required.
+
+Now that you have the first reflection it can be stored using the following command:
+
+saveref('reflable',[h k l])
+
+saveref('Ti1',[0 0 2]) for the above example.
+
+Then create a dummy UB matrix using a dummy non-parallel hkl plane eg:
+
+ubm('Ti1',[2 0 0])
+
+Useing the following command to calculate the direction of the second reflection:
+
+hkl_calc([0 2 2])
+
+If the calculated positions can be safely achieved then type:
+
+pos hkl [0 2 2]
+
+Find the second reflection by scanning phi, once the reflection is found save the second reflection using:
+
+saveref('Ti2',[0 2 2]) for example.
+
+Now create a real UB-Matrix using:
+
+ubm('Ti1','Ti2')
+
+You can now drive in recriprocal space.
+
+To change the lattice parameters according the found Bragg peaks
+
+latt([latt()[0]*2/l()]) (cubic only)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/install-jython-environment.sh b/script/test/diffcalc (copy)/install-jython-environment.sh
new file mode 100755
index 0000000..4ac8ef1
--- /dev/null
+++ b/script/test/diffcalc (copy)/install-jython-environment.sh	
@@ -0,0 +1,19 @@
+#!/usr/bin/env sh
+
+JYTHON_URL='http://search.maven.org/remotecontent?filepath=org/python/jython-installer/2.7.1/jython-installer-2.7.1.jar'
+JAMA_JAR_URL='http://math.nist.gov/javanumerics/jama/Jama-1.0.3.jar'
+
+# Install Jama jar
+mkdir -p lib
+wget -P $HOME/lib $JAMA_JAR_URL
+export CLASSPATH=$HOME/lib/Jama-1.0.3.jar:$CLASSPATH
+
+# Install Jython
+wget $JYTHON_URL -O jython_installer.jar
+java -jar jython_installer.jar -s -d $HOME/jython
+
+# Install nose for Jython
+# TODO: move to a setup.py
+$HOME/jython/bin/pip install nose
+$HOME/jython/bin/pip install pytest==3.2.3
+$HOME/jython/bin/pip install pytest-xdist
diff --git a/script/test/diffcalc (copy)/integration_checks.py b/script/test/diffcalc (copy)/integration_checks.py
new file mode 100644
index 0000000..d3fdacc
--- /dev/null
+++ b/script/test/diffcalc (copy)/integration_checks.py	
@@ -0,0 +1,72 @@
+'''
+Created on 9 Mar 2017
+
+@author: zrb13439
+
+'''
+
+'''
+Integration tests for startup scripts (named so that nosetests will *not* pick
+up by default.
+
+This is because these must be run with:
+
+    $ nosetests --with-process-isolation integration_checks.py
+
+This is not a standard nose option. Install it with:
+
+    $ pip install nosepipe
+
+nosepipe is described at https://github.com/dmccombs/nosepipe/
+'''
+
+from nose import SkipTest
+
+
+def test_sixcircle_startup():
+    import startup.sixcircle
+    startup.sixcircle.ct.pause = False
+    startup.sixcircle.demo.all()
+
+
+def test_fivecircle_startup():
+    import startup.fivecircle
+    startup.fivecircle.ct.pause = False
+    startup.fivecircle.demo.all()
+
+
+def test_fourcircle_startup():
+    import startup.fourcircle
+    startup.fourcircle.ct.pause = False
+    startup.fourcircle.demo.all()
+
+
+def test_i13_startup():
+    raise SkipTest('Still need to work out to use i13s very tight limits')
+    import startup.i13
+    startup.i13.ct.pause = False
+    startup.i13.demo.all()
+
+
+def test_i16_startup():
+    import startup.i16
+    startup.i16.ct.pause = False
+    startup.i16.demo.all()
+
+
+def test_i21_startup_standard():
+    import startup.i21
+    startup.i21.ct.pause = False
+    startup.i21.demo.all()
+
+
+def test_i21_startup_bespoke():
+    import startup.i21
+    startup.i21.ct.pause = False
+    startup.i21.demo.i21()
+    
+    
+def test_sixcirle_api():
+    import startup.api.sixcircle
+    startup.api.sixcircle.demo_all()
+
diff --git a/script/test/diffcalc (copy)/mock.py b/script/test/diffcalc (copy)/mock.py
new file mode 100644
index 0000000..24799cf
--- /dev/null
+++ b/script/test/diffcalc (copy)/mock.py	
@@ -0,0 +1,2288 @@
+# mock.py
+# Test tools for mocking and patching.
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+
+# mock 0.8.0
+# http://www.voidspace.org.uk/python/mock/
+
+# Released subject to the BSD License
+# Please see http://www.voidspace.org.uk/python/license.shtml
+
+# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
+# Comments, suggestions and bug reports welcome.
+
+
+__all__ = (
+    'Mock',
+    'MagicMock',
+    'mocksignature',
+    'patch',
+    'sentinel',
+    'DEFAULT',
+    'ANY',
+    'call',
+    'create_autospec',
+    'FILTER_DIR',
+    'NonCallableMock',
+    'NonCallableMagicMock',
+)
+
+
+__version__ = '0.8.0'
+
+
+import pprint
+import sys
+
+try:
+    import inspect
+except ImportError:
+    # for alternative platforms that
+    # may not have inspect
+    inspect = None
+
+try:
+    from functools import wraps
+except ImportError:
+    # Python 2.4 compatibility
+    def wraps(original):
+        def inner(f):
+            f.__name__ = original.__name__
+            f.__doc__ = original.__doc__
+            f.__module__ = original.__module__
+            return f
+        return inner
+
+try:
+    unicode
+except NameError:
+    # Python 3
+    basestring = unicode = str
+
+try:
+    long
+except NameError:
+    # Python 3
+    long = int
+
+try:
+    BaseException
+except NameError:
+    # Python 2.4 compatibility
+    BaseException = Exception
+
+try:
+    next
+except NameError:
+    def next(obj):
+        return obj.next()
+
+
+BaseExceptions = (BaseException,)
+if 'java' in sys.platform:
+    # jython
+    import java
+    BaseExceptions = (BaseException, java.lang.Throwable)
+
+try:
+    _isidentifier = str.isidentifier
+except AttributeError:
+    # Python 2.X
+    import keyword
+    import re
+    regex = re.compile(r'^[a-z_][a-z0-9_]*$', re.I)
+    def _isidentifier(string):
+        if string in keyword.kwlist:
+            return False
+        return regex.match(string)
+
+
+inPy3k = sys.version_info[0] == 3
+
+# Needed to work around Python 3 bug where use of "super" interferes with
+# defining __class__ as a descriptor
+_super = super
+
+self = 'im_self'
+builtin = '__builtin__'
+if inPy3k:
+    self = '__self__'
+    builtin = 'builtins'
+
+FILTER_DIR = True
+
+
+def _is_instance_mock(obj):
+    # can't use isinstance on Mock objects because they override __class__
+    # The base class for all mocks is NonCallableMock
+    return issubclass(type(obj), NonCallableMock)
+
+
+def _is_exception(obj):
+    return (
+        isinstance(obj, BaseExceptions) or
+        isinstance(obj, ClassTypes) and issubclass(obj, BaseExceptions)
+    )
+
+
+class _slotted(object):
+    __slots__ = ['a']
+
+
+DescriptorTypes = (
+    type(_slotted.a),
+    property,
+)
+
+
+# getsignature and mocksignature heavily "inspired" by
+# the decorator module: http://pypi.python.org/pypi/decorator/
+# by Michele Simionato
+
+def _getsignature(func, skipfirst):
+    if inspect is None:
+        raise ImportError('inspect module not available')
+
+    if inspect.isclass(func):
+        func = func.__init__
+        # will have a self arg
+        skipfirst = True
+    elif not (inspect.ismethod(func) or inspect.isfunction(func)):
+        func = func.__call__
+
+    regargs, varargs, varkwargs, defaults = inspect.getargspec(func)
+
+    # instance methods need to lose the self argument
+    if getattr(func, self, None) is not None:
+        regargs = regargs[1:]
+
+    _msg = ("_mock_ is a reserved argument name, can't mock signatures using "
+            "_mock_")
+    assert '_mock_' not in regargs, _msg
+    if varargs is not None:
+        assert '_mock_' not in varargs, _msg
+    if varkwargs is not None:
+        assert '_mock_' not in varkwargs, _msg
+    if skipfirst:
+        regargs = regargs[1:]
+
+    signature = inspect.formatargspec(regargs, varargs, varkwargs, defaults,
+                                      formatvalue=lambda value: "")
+    return signature[1:-1], func
+
+
+def _getsignature2(func, skipfirst, instance=False):
+    if inspect is None:
+        raise ImportError('inspect module not available')
+
+    if isinstance(func, ClassTypes) and not instance:
+        try:
+            func = func.__init__
+        except AttributeError:
+            return
+        skipfirst = True
+    elif not isinstance(func, FunctionTypes):
+        # for classes where instance is True we end up here too
+        try:
+            func = func.__call__
+        except AttributeError:
+            return
+
+    try:
+        regargs, varargs, varkwargs, defaults = inspect.getargspec(func)
+    except TypeError:
+        # C function / method, possibly inherited object().__init__
+        return
+
+    # instance methods and classmethods need to lose the self argument
+    if getattr(func, self, None) is not None:
+        regargs = regargs[1:]
+    if skipfirst:
+        # this condition and the above one are never both True - why?
+        regargs = regargs[1:]
+
+    signature = inspect.formatargspec(regargs, varargs, varkwargs, defaults,
+                                      formatvalue=lambda value: "")
+    return signature[1:-1], func
+
+
+def _check_signature(func, mock, skipfirst, instance=False):
+    if not _callable(func):
+        return
+
+    result = _getsignature2(func, skipfirst, instance)
+    if result is None:
+        return
+    signature, func = result
+
+    # can't use self because "self" is common as an argument name
+    # unfortunately even not in the first place
+    src = "lambda _mock_self, %s: None" % signature
+    checksig = eval(src, {})
+    _copy_func_details(func, checksig)
+    type(mock)._mock_check_sig = checksig
+
+
+def _copy_func_details(func, funcopy):
+    funcopy.__name__ = func.__name__
+    funcopy.__doc__ = func.__doc__
+    #funcopy.__dict__.update(func.__dict__)
+    funcopy.__module__ = func.__module__
+    if not inPy3k:
+        funcopy.func_defaults = func.func_defaults
+        return
+    funcopy.__defaults__ = func.__defaults__
+    funcopy.__kwdefaults__ = func.__kwdefaults__
+
+
+def _callable(obj):
+    if isinstance(obj, ClassTypes):
+        return True
+    if getattr(obj, '__call__', None) is not None:
+        return True
+    return False
+
+
+def _is_list(obj):
+    # checks for list or tuples
+    # XXXX badly named!
+    return type(obj) in (list, tuple)
+
+
+def _instance_callable(obj):
+    """Given an object, return True if the object is callable.
+    For classes, return True if instances would be callable."""
+    if not isinstance(obj, ClassTypes):
+        # already an instance
+        return getattr(obj, '__call__', None) is not None
+
+    klass = obj
+    # uses __bases__ instead of __mro__ so that we work with old style classes
+    if klass.__dict__.get('__call__') is not None:
+        return True
+
+    for base in klass.__bases__:
+        if _instance_callable(base):
+            return True
+    return False
+
+
+def _set_signature(mock, original, instance=False):
+    # creates a function with signature (*args, **kwargs) that delegates to a
+    # mock. It still does signature checking by calling a lambda with the same
+    # signature as the original. This is effectively mocksignature2.
+    if not _callable(original):
+        return
+
+    skipfirst = isinstance(original, ClassTypes)
+    result = _getsignature2(original, skipfirst, instance)
+    if result is None:
+        # was a C function (e.g. object().__init__ ) that can't be mocked
+        return
+
+    signature, func = result
+
+    src = "lambda %s: None" % signature
+    context = {'_mock_': mock}
+    checksig = eval(src, context)
+    _copy_func_details(func, checksig)
+
+    name = original.__name__
+    if not _isidentifier(name):
+        name = 'funcopy'
+    context = {'checksig': checksig, 'mock': mock}
+    src = """def %s(*args, **kwargs):
+    checksig(*args, **kwargs)
+    return mock(*args, **kwargs)""" % name
+    exec (src, context)
+    funcopy = context[name]
+    _setup_func(funcopy, mock)
+    return funcopy
+
+
+def mocksignature(func, mock=None, skipfirst=False):
+    """
+    mocksignature(func, mock=None, skipfirst=False)
+
+    Create a new function with the same signature as `func` that delegates
+    to `mock`. If `skipfirst` is True the first argument is skipped, useful
+    for methods where `self` needs to be omitted from the new function.
+
+    If you don't pass in a `mock` then one will be created for you.
+
+    The mock is set as the `mock` attribute of the returned function for easy
+    access.
+
+    Functions returned by `mocksignature` have many of the same attributes
+    and assert methods as a mock object.
+
+    `mocksignature` can also be used with classes. It copies the signature of
+    the `__init__` method.
+
+    When used with callable objects (instances) it copies the signature of the
+    `__call__` method.
+    """
+    if mock is None:
+        mock = Mock()
+    signature, func = _getsignature(func, skipfirst)
+    src = "lambda %(signature)s: _mock_(%(signature)s)" % {
+        'signature': signature
+    }
+
+    funcopy = eval(src, dict(_mock_=mock))
+    _copy_func_details(func, funcopy)
+    _setup_func(funcopy, mock)
+    return funcopy
+
+
+def _setup_func(funcopy, mock):
+    funcopy.mock = mock
+
+    # can't use isinstance with mocks
+    if not _is_instance_mock(mock):
+        return
+
+    def assert_called_with(*args, **kwargs):
+        return mock.assert_called_with(*args, **kwargs)
+    def assert_called_once_with(*args, **kwargs):
+        return mock.assert_called_once_with(*args, **kwargs)
+    def assert_has_calls(*args, **kwargs):
+        return mock.assert_has_calls(*args, **kwargs)
+    def assert_any_call(*args, **kwargs):
+        return mock.assert_any_call(*args, **kwargs)
+    def reset_mock():
+        funcopy.method_calls = _CallList()
+        funcopy.mock_calls = _CallList()
+        mock.reset_mock()
+        ret = funcopy.return_value
+        if _is_instance_mock(ret) and not ret is mock:
+            ret.reset_mock()
+
+    funcopy.called = False
+    funcopy.call_count = 0
+    funcopy.call_args = None
+    funcopy.call_args_list = _CallList()
+    funcopy.method_calls = _CallList()
+    funcopy.mock_calls = _CallList()
+
+    funcopy.return_value = mock.return_value
+    funcopy.side_effect = mock.side_effect
+    funcopy._mock_children = mock._mock_children
+
+    funcopy.assert_called_with = assert_called_with
+    funcopy.assert_called_once_with = assert_called_once_with
+    funcopy.assert_has_calls = assert_has_calls
+    funcopy.assert_any_call = assert_any_call
+    funcopy.reset_mock = reset_mock
+
+    mock._mock_signature = funcopy
+
+
+def _is_magic(name):
+    return '__%s__' % name[2:-2] == name
+
+
+class _SentinelObject(object):
+    "A unique, named, sentinel object."
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return 'sentinel.%s' % self.name
+
+
+class _Sentinel(object):
+    """Access attributes to return a named object, usable as a sentinel."""
+    def __init__(self):
+        self._sentinels = {}
+
+    def __getattr__(self, name):
+        if name == '__bases__':
+            # Without this help(mock) raises an exception
+            raise AttributeError
+        return self._sentinels.setdefault(name, _SentinelObject(name))
+
+
+sentinel = _Sentinel()
+
+DEFAULT = sentinel.DEFAULT
+
+
+class OldStyleClass:
+    pass
+ClassType = type(OldStyleClass)
+
+
+def _copy(value):
+    if type(value) in (dict, list, tuple, set):
+        return type(value)(value)
+    return value
+
+
+ClassTypes = (type,)
+if not inPy3k:
+    ClassTypes = (type, ClassType)
+
+_allowed_names = set(
+    [
+        'return_value', '_mock_return_value', 'side_effect',
+        '_mock_side_effect', '_mock_parent', '_mock_new_parent',
+        '_mock_name', '_mock_new_name'
+    ]
+)
+
+
+def _mock_signature_property(name):
+    _allowed_names.add(name)
+    _the_name = '_mock_' + name
+    def _get(self, name=name, _the_name=_the_name):
+        sig = self._mock_signature
+        if sig is None:
+            return getattr(self, _the_name)
+        return getattr(sig, name)
+    def _set(self, value, name=name, _the_name=_the_name):
+        sig = self._mock_signature
+        if sig is None:
+            self.__dict__[_the_name] = value
+        else:
+            setattr(sig, name, value)
+
+    return property(_get, _set)
+
+
+
+class _CallList(list):
+
+    def __contains__(self, value):
+        if not isinstance(value, list):
+            return list.__contains__(self, value)
+        len_value = len(value)
+        len_self = len(self)
+        if len_value > len_self:
+            return False
+
+        for i in range(0, len_self - len_value + 1):
+            sub_list = self[i:i+len_value]
+            if sub_list == value:
+                return True
+        return False
+
+    def __repr__(self):
+        return pprint.pformat(list(self))
+
+
+def _check_and_set_parent(parent, value, name, new_name):
+    if not _is_instance_mock(value):
+        return False
+    if ((value._mock_name or value._mock_new_name) or
+        (value._mock_parent is not None) or
+        (value._mock_new_parent is not None)):
+        return False
+
+    _parent = parent
+    while _parent is not None:
+        # setting a mock (value) as a child or return value of itself
+        # should not modify the mock
+        if _parent is value:
+            return False
+        _parent = _parent._mock_new_parent
+
+    if new_name:
+        value._mock_new_parent = parent
+        value._mock_new_name = new_name
+    if name:
+        value._mock_parent = parent
+        value._mock_name = name
+    return True
+
+
+
+class Base(object):
+    _mock_return_value = DEFAULT
+    _mock_side_effect = None
+    def __init__(self, *args, **kwargs):
+        pass
+
+
+
+class NonCallableMock(Base):
+    """A non-callable version of `Mock`"""
+
+    def __new__(cls, *args, **kw):
+        # every instance has its own class
+        # so we can create magic methods on the
+        # class without stomping on other mocks
+        new = type(cls.__name__, (cls,), {'__doc__': cls.__doc__})
+        instance = object.__new__(new)
+        return instance
+
+
+    def __init__(
+            self, spec=None, wraps=None, name=None, spec_set=None,
+            parent=None, _spec_state=None, _new_name='', _new_parent=None,
+            **kwargs
+        ):
+        if _new_parent is None:
+            _new_parent = parent
+
+        __dict__ = self.__dict__
+        __dict__['_mock_parent'] = parent
+        __dict__['_mock_name'] = name
+        __dict__['_mock_new_name'] = _new_name
+        __dict__['_mock_new_parent'] = _new_parent
+
+        if spec_set is not None:
+            spec = spec_set
+            spec_set = True
+
+        self._mock_add_spec(spec, spec_set)
+
+        __dict__['_mock_children'] = {}
+        __dict__['_mock_wraps'] = wraps
+        __dict__['_mock_signature'] = None
+
+        __dict__['_mock_called'] = False
+        __dict__['_mock_call_args'] = None
+        __dict__['_mock_call_count'] = 0
+        __dict__['_mock_call_args_list'] = _CallList()
+        __dict__['_mock_mock_calls'] = _CallList()
+
+        __dict__['method_calls'] = _CallList()
+
+        if kwargs:
+            self.configure_mock(**kwargs)
+
+        _super(NonCallableMock, self).__init__(
+            spec, wraps, name, spec_set, parent,
+            _spec_state
+        )
+
+
+    def attach_mock(self, mock, attribute):
+        """
+        Attach a mock as an attribute of this one, replacing its name and
+        parent. Calls to the attached mock will be recorded in the
+        `method_calls` and `mock_calls` attributes of this one."""
+        mock._mock_parent = None
+        mock._mock_new_parent = None
+        mock._mock_name = ''
+        mock._mock_new_name = None
+
+        setattr(self, attribute, mock)
+
+
+    def mock_add_spec(self, spec, spec_set=False):
+        """Add a spec to a mock. `spec` can either be an object or a
+        list of strings. Only attributes on the `spec` can be fetched as
+        attributes from the mock.
+
+        If `spec_set` is True then only attributes on the spec can be set."""
+        self._mock_add_spec(spec, spec_set)
+
+
+    def _mock_add_spec(self, spec, spec_set):
+        _spec_class = None
+
+        if spec is not None and not _is_list(spec):
+            if isinstance(spec, ClassTypes):
+                _spec_class = spec
+            else:
+                _spec_class = _get_class(spec)
+
+            spec = dir(spec)
+
+        __dict__ = self.__dict__
+        __dict__['_spec_class'] = _spec_class
+        __dict__['_spec_set'] = spec_set
+        __dict__['_mock_methods'] = spec
+
+
+    def __get_return_value(self):
+        ret = self._mock_return_value
+        if self._mock_signature is not None:
+            ret = self._mock_signature.return_value
+
+        if ret is DEFAULT:
+            ret = self._get_child_mock(
+                _new_parent=self, _new_name='()'
+            )
+            self.return_value = ret
+        return ret
+
+
+    def __set_return_value(self, value):
+        if self._mock_signature is not None:
+            self._mock_signature.return_value = value
+        else:
+            self._mock_return_value = value
+            _check_and_set_parent(self, value, None, '()')
+
+    __return_value_doc = "The value to be returned when the mock is called."
+    return_value = property(__get_return_value, __set_return_value,
+                            __return_value_doc)
+
+
+    @property
+    def __class__(self):
+        if self._spec_class is None:
+            return type(self)
+        return self._spec_class
+
+    called = _mock_signature_property('called')
+    call_count = _mock_signature_property('call_count')
+    call_args = _mock_signature_property('call_args')
+    call_args_list = _mock_signature_property('call_args_list')
+    mock_calls = _mock_signature_property('mock_calls')
+
+
+    def __get_side_effect(self):
+        sig = self._mock_signature
+        if sig is None:
+            return self._mock_side_effect
+        return sig.side_effect
+
+    def __set_side_effect(self, value):
+        value = _try_iter(value)
+        sig = self._mock_signature
+        if sig is None:
+            self._mock_side_effect = value
+        else:
+            sig.side_effect = value
+
+    side_effect = property(__get_side_effect, __set_side_effect)
+
+
+    def reset_mock(self):
+        "Restore the mock object to its initial state."
+        self.called = False
+        self.call_args = None
+        self.call_count = 0
+        self.mock_calls = _CallList()
+        self.call_args_list = _CallList()
+        self.method_calls = _CallList()
+
+        for child in self._mock_children.values():
+            child.reset_mock()
+
+        ret = self._mock_return_value
+        if _is_instance_mock(ret) and ret is not self:
+            ret.reset_mock()
+
+
+    def configure_mock(self, **kwargs):
+        """Set attributes on the mock through keyword arguments.
+
+        Attributes plus return values and side effects can be set on child
+        mocks using standard dot notation and unpacking a dictionary in the
+        method call:
+
+        >>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
+        >>> mock.configure_mock(**attrs)"""
+        for arg, val in sorted(kwargs.items(),
+                               # we sort on the number of dots so that
+                               # attributes are set before we set attributes on
+                               # attributes
+                               key=lambda entry: entry[0].count('.')):
+            args = arg.split('.')
+            final = args.pop()
+            obj = self
+            for entry in args:
+                obj = getattr(obj, entry)
+            setattr(obj, final, val)
+
+
+    def __getattr__(self, name):
+        if name == '_mock_methods':
+            raise AttributeError(name)
+        elif self._mock_methods is not None:
+            if name not in self._mock_methods or name in _all_magics:
+                raise AttributeError("Mock object has no attribute %r" % name)
+        elif _is_magic(name):
+            raise AttributeError(name)
+
+        result = self._mock_children.get(name)
+        if result is None:
+            wraps = None
+            if self._mock_wraps is not None:
+                # XXXX should we get the attribute without triggering code
+                # execution?
+                wraps = getattr(self._mock_wraps, name)
+
+            result = self._get_child_mock(
+                parent=self, name=name, wraps=wraps, _new_name=name,
+                _new_parent=self
+            )
+            self._mock_children[name]  = result
+
+        elif isinstance(result, _SpecState):
+            result = create_autospec(
+                result.spec, result.spec_set, result.instance,
+                result.parent, result.name
+            )
+            self._mock_children[name]  = result
+
+        return result
+
+
+    def __repr__(self):
+        _name_list = [self._mock_new_name]
+        _parent = self._mock_new_parent
+        last = self
+
+        dot = '.'
+        if _name_list == ['()']:
+            dot = ''
+        seen = set()
+        while _parent is not None:
+            last = _parent
+
+            _name_list.append(_parent._mock_new_name + dot)
+            dot = '.'
+            if _parent._mock_new_name == '()':
+                dot = ''
+
+            _parent = _parent._mock_new_parent
+
+            # use ids here so as not to call __hash__ on the mocks
+            if id(_parent) in seen:
+                break
+            seen.add(id(_parent))
+
+        _name_list = list(reversed(_name_list))
+        _first = last._mock_name or 'mock'
+        if len(_name_list) > 1:
+            if _name_list[1] not in ('()', '().'):
+                _first += '.'
+        _name_list[0] = _first
+        name = ''.join(_name_list)
+
+        name_string = ''
+        if name not in ('mock', 'mock.'):
+            name_string = ' name=%r' % name
+
+        spec_string = ''
+        if self._spec_class is not None:
+            spec_string = ' spec=%r'
+            if self._spec_set:
+                spec_string = ' spec_set=%r'
+            spec_string = spec_string % self._spec_class.__name__
+        return "<%s%s%s id='%s'>" % (
+            type(self).__name__,
+            name_string,
+            spec_string,
+            id(self)
+        )
+
+
+    def __dir__(self):
+        """Filter the output of `dir(mock)` to only useful members.
+        XXXX
+        """
+        extras = self._mock_methods or []
+        from_type = dir(type(self))
+        from_dict = list(self.__dict__)
+
+        if FILTER_DIR:
+            from_type = [e for e in from_type if not e.startswith('_')]
+            from_dict = [e for e in from_dict if not e.startswith('_') or
+                         _is_magic(e)]
+        return sorted(set(extras + from_type + from_dict +
+                          list(self._mock_children)))
+
+
+    def __setattr__(self, name, value):
+        if name in _allowed_names:
+            # property setters go through here
+            return object.__setattr__(self, name, value)
+        elif (self._spec_set and self._mock_methods is not None and
+            name not in self._mock_methods and
+            name not in self.__dict__):
+            raise AttributeError("Mock object has no attribute '%s'" % name)
+        elif name in _unsupported_magics:
+            msg = 'Attempting to set unsupported magic method %r.' % name
+            raise AttributeError(msg)
+        elif name in _all_magics:
+            if self._mock_methods is not None and name not in self._mock_methods:
+                raise AttributeError("Mock object has no attribute '%s'" % name)
+
+            if not _is_instance_mock(value):
+                setattr(type(self), name, _get_method(name, value))
+                original = value
+                real = lambda *args, **kw: original(self, *args, **kw)
+                value = mocksignature(value, real, skipfirst=True)
+            else:
+                # only set _new_name and not name so that mock_calls is tracked
+                # but not method calls
+                _check_and_set_parent(self, value, None, name)
+                setattr(type(self), name, value)
+        else:
+            if _check_and_set_parent(self, value, name, name):
+                self._mock_children[name] = value
+        return object.__setattr__(self, name, value)
+
+
+    def __delattr__(self, name):
+        if name in _all_magics and name in type(self).__dict__:
+            delattr(type(self), name)
+            if name not in self.__dict__:
+                # for magic methods that are still MagicProxy objects and
+                # not set on the instance itself
+                return
+
+        return object.__delattr__(self, name)
+
+
+    def _format_mock_call_signature(self, args, kwargs):
+        name = self._mock_name or 'mock'
+        return _format_call_signature(name, args, kwargs)
+
+
+    def _format_mock_failure_message(self, args, kwargs):
+        message = 'Expected call: %s\nActual call: %s'
+        expected_string = self._format_mock_call_signature(args, kwargs)
+        call_args = self.call_args
+        if len(call_args) == 3:
+            call_args = call_args[1:]
+        actual_string = self._format_mock_call_signature(*call_args)
+        return message % (expected_string, actual_string)
+
+
+    def assert_called_with(_mock_self, *args, **kwargs):
+        """assert that the mock was called with the specified arguments.
+
+        Raises an AssertionError if the args and keyword args passed in are
+        different to the last call to the mock."""
+        self = _mock_self
+        if self.call_args is None:
+            expected = self._format_mock_call_signature(args, kwargs)
+            raise AssertionError('Expected call: %s\nNot called' % (expected,))
+
+        if self.call_args != (args, kwargs):
+            msg = self._format_mock_failure_message(args, kwargs)
+            raise AssertionError(msg)
+
+
+    def assert_called_once_with(_mock_self, *args, **kwargs):
+        """assert that the mock was called exactly once and with the specified
+        arguments."""
+        self = _mock_self
+        if not self.call_count == 1:
+            msg = ("Expected to be called once. Called %s times." %
+                   self.call_count)
+            raise AssertionError(msg)
+        return self.assert_called_with(*args, **kwargs)
+
+
+    def assert_has_calls(self, calls, any_order=False):
+        """assert the mock has been called with the specified calls.
+        The `mock_calls` list is checked for the calls.
+
+        If `any_order` is False (the default) then the calls must be
+        sequential. There can be extra calls before or after the
+        specified calls.
+
+        If `any_order` is True then the calls can be in any order, but
+        they must all appear in `mock_calls`."""
+        if not any_order:
+            if calls not in self.mock_calls:
+                raise AssertionError(
+                    'Calls not found.\nExpected: %r\n'
+                    'Actual: %r' % (calls, self.mock_calls)
+                )
+            return
+
+        all_calls = list(self.mock_calls)
+
+        not_found = []
+        for kall in calls:
+            try:
+                all_calls.remove(kall)
+            except ValueError:
+                not_found.append(kall)
+        if not_found:
+            raise AssertionError(
+                '%r not all found in call list' % (tuple(not_found),)
+            )
+
+
+    def assert_any_call(self, *args, **kwargs):
+        """assert the mock has been called with the specified arguments.
+
+        The assert passes if the mock has *ever* been called, unlike
+        `assert_called_with` and `assert_called_once_with` that only pass if
+        the call is the most recent one."""
+        kall = call(*args, **kwargs)
+        if kall not in self.call_args_list:
+            expected_string = self._format_mock_call_signature(args, kwargs)
+            raise AssertionError(
+                '%s call not found' % expected_string
+            )
+
+
+    def _get_child_mock(self, **kw):
+        """Create the child mocks for attributes and return value.
+        By default child mocks will be the same type as the parent.
+        Subclasses of Mock may want to override this to customize the way
+        child mocks are made.
+
+        For non-callable mocks the callable variant will be used (rather than
+        any custom subclass)."""
+        _type = type(self)
+        if not issubclass(_type, CallableMixin):
+            if issubclass(_type, NonCallableMagicMock):
+                klass = MagicMock
+            elif issubclass(_type, NonCallableMock) :
+                klass = Mock
+        else:
+            klass = _type.__mro__[1]
+        return klass(**kw)
+
+
+
+def _try_iter(obj):
+    if obj is None:
+        return obj
+    if _is_exception(obj):
+        return obj
+    if _callable(obj):
+        return obj
+    try:
+        return iter(obj)
+    except TypeError:
+        # XXXX backwards compatibility
+        # but this will blow up on first call - so maybe we should fail early?
+        return obj
+
+
+
+class CallableMixin(Base):
+
+    def __init__(self, spec=None, side_effect=None, return_value=DEFAULT,
+                 wraps=None, name=None, spec_set=None, parent=None,
+                 _spec_state=None, _new_name='', _new_parent=None, **kwargs):
+        self.__dict__['_mock_return_value'] = return_value
+
+        _super(CallableMixin, self).__init__(
+            spec, wraps, name, spec_set, parent,
+            _spec_state, _new_name, _new_parent, **kwargs
+        )
+
+        self.side_effect = side_effect
+
+
+    def _mock_check_sig(self, *args, **kwargs):
+        # stub method that can be replaced with one with a specific signature
+        pass
+
+
+    def __call__(_mock_self, *args, **kwargs):
+        # can't use self in-case a function / method we are mocking uses self
+        # in the signature
+        _mock_self._mock_check_sig(*args, **kwargs)
+        return _mock_self._mock_call(*args, **kwargs)
+
+
+    def _mock_call(_mock_self, *args, **kwargs):
+        self = _mock_self
+        self.called = True
+        self.call_count += 1
+        self.call_args = _Call((args, kwargs), two=True)
+        self.call_args_list.append(_Call((args, kwargs), two=True))
+
+        _new_name = self._mock_new_name
+        _new_parent = self._mock_new_parent
+        self.mock_calls.append(_Call(('', args, kwargs)))
+
+        seen = set()
+        skip_next_dot = _new_name == '()'
+        do_method_calls = self._mock_parent is not None
+        name = self._mock_name
+        while _new_parent is not None:
+            this_mock_call = _Call((_new_name, args, kwargs))
+            if _new_parent._mock_new_name:
+                dot = '.'
+                if skip_next_dot:
+                    dot = ''
+
+                skip_next_dot = False
+                if _new_parent._mock_new_name == '()':
+                    skip_next_dot = True
+
+                _new_name = _new_parent._mock_new_name + dot + _new_name
+
+            if do_method_calls:
+                if _new_name == name:
+                    this_method_call = this_mock_call
+                else:
+                    this_method_call = _Call((name, args, kwargs))
+                _new_parent.method_calls.append(this_method_call)
+
+                do_method_calls = _new_parent._mock_parent is not None
+                if do_method_calls:
+                    name = _new_parent._mock_name + '.' + name
+
+            _new_parent.mock_calls.append(this_mock_call)
+            _new_parent = _new_parent._mock_new_parent
+
+            # use ids here so as not to call __hash__ on the mocks
+            _new_parent_id = id(_new_parent)
+            if _new_parent_id in seen:
+                break
+            seen.add(_new_parent_id)
+
+        ret_val = DEFAULT
+        effect = self.side_effect
+        if effect is not None:
+            if _is_exception(effect):
+                raise effect
+
+            if not _callable(effect):
+                return next(effect)
+
+            ret_val = effect(*args, **kwargs)
+            if ret_val is DEFAULT:
+                ret_val = self.return_value
+
+        if (self._mock_wraps is not None and
+             self._mock_return_value is DEFAULT):
+            return self._mock_wraps(*args, **kwargs)
+        if ret_val is DEFAULT:
+            ret_val = self.return_value
+        return ret_val
+
+
+
+class Mock(CallableMixin, NonCallableMock):
+    """
+    Create a new `Mock` object. `Mock` takes several optional arguments
+    that specify the behaviour of the Mock object:
+
+    * `spec`: This can be either a list of strings or an existing object (a
+      class or instance) that acts as the specification for the mock object. If
+      you pass in an object then a list of strings is formed by calling dir on
+      the object (excluding unsupported magic attributes and methods). Accessing
+      any attribute not in this list will raise an `AttributeError`.
+
+      If `spec` is an object (rather than a list of strings) then
+      `mock.__class__` returns the class of the spec object. This allows mocks
+      to pass `isinstance` tests.
+
+    * `spec_set`: A stricter variant of `spec`. If used, attempting to *set*
+      or get an attribute on the mock that isn't on the object passed as
+      `spec_set` will raise an `AttributeError`.
+
+    * `side_effect`: A function to be called whenever the Mock is called. See
+      the `side_effect` attribute. Useful for raising exceptions or
+      dynamically changing return values. The function is called with the same
+      arguments as the mock, and unless it returns `DEFAULT`, the return
+      value of this function is used as the return value.
+
+      Alternatively `side_effect` can be an exception class or instance. In
+      this case the exception will be raised when the mock is called.
+
+      If `side_effect` is an iterable then each call to the mock will return
+      the next value from the iterable.
+
+    * `return_value`: The value returned when the mock is called. By default
+      this is a new Mock (created on first access). See the
+      `return_value` attribute.
+
+    * `wraps`: Item for the mock object to wrap. If `wraps` is not None
+      then calling the Mock will pass the call through to the wrapped object
+      (returning the real result and ignoring `return_value`). Attribute
+      access on the mock will return a Mock object that wraps the corresponding
+      attribute of the wrapped object (so attempting to access an attribute that
+      doesn't exist will raise an `AttributeError`).
+
+      If the mock has an explicit `return_value` set then calls are not passed
+      to the wrapped object and the `return_value` is returned instead.
+
+    * `name`: If the mock has a name then it will be used in the repr of the
+      mock. This can be useful for debugging. The name is propagated to child
+      mocks.
+
+    Mocks can also be called with arbitrary keyword arguments. These will be
+    used to set attributes on the mock after it is created.
+    """
+
+
+
+def _dot_lookup(thing, comp, import_path):
+    try:
+        return getattr(thing, comp)
+    except AttributeError:
+        __import__(import_path)
+        return getattr(thing, comp)
+
+
+def _importer(target):
+    components = target.split('.')
+    import_path = components.pop(0)
+    thing = __import__(import_path)
+
+    for comp in components:
+        import_path += ".%s" % comp
+        thing = _dot_lookup(thing, comp, import_path)
+    return thing
+
+
+def _is_started(patcher):
+    # XXXX horrible
+    return hasattr(patcher, 'is_local')
+
+
+class _patch(object):
+
+    attribute_name = None
+
+    def __init__(
+            self, getter, attribute, new, spec, create,
+            mocksignature, spec_set, autospec, new_callable, kwargs
+        ):
+        if new_callable is not None:
+            if new is not DEFAULT:
+                raise ValueError(
+                    "Cannot use 'new' and 'new_callable' together"
+                )
+            if autospec is not False:
+                raise ValueError(
+                    "Cannot use 'autospec' and 'new_callable' together"
+                )
+
+        self.getter = getter
+        self.attribute = attribute
+        self.new = new
+        self.new_callable = new_callable
+        self.spec = spec
+        self.create = create
+        self.has_local = False
+        self.mocksignature = mocksignature
+        self.spec_set = spec_set
+        self.autospec = autospec
+        self.kwargs = kwargs
+        self.additional_patchers = []
+
+
+    def copy(self):
+        patcher = _patch(
+            self.getter, self.attribute, self.new, self.spec,
+            self.create, self.mocksignature, self.spec_set,
+            self.autospec, self.new_callable, self.kwargs
+        )
+        patcher.attribute_name = self.attribute_name
+        patcher.additional_patchers = [
+            p.copy() for p in self.additional_patchers
+        ]
+        return patcher
+
+
+    def __call__(self, func):
+        if isinstance(func, ClassTypes):
+            return self.decorate_class(func)
+        return self.decorate_callable(func)
+
+
+    def decorate_class(self, klass):
+        for attr in dir(klass):
+            if not attr.startswith(patch.TEST_PREFIX):
+                continue
+
+            attr_value = getattr(klass, attr)
+            if not hasattr(attr_value, "__call__"):
+                continue
+
+            patcher = self.copy()
+            setattr(klass, attr, patcher(attr_value))
+        return klass
+
+
+    def decorate_callable(self, func):
+        if hasattr(func, 'patchings'):
+            func.patchings.append(self)
+            return func
+
+        @wraps(func)
+        def patched(*args, **keywargs):
+            # don't use a with here (backwards compatability with Python 2.4)
+            extra_args = []
+            entered_patchers = []
+
+            # can't use try...except...finally because of Python 2.4
+            # compatibility
+            try:
+                try:
+                    for patching in patched.patchings:
+                        arg = patching.__enter__()
+                        entered_patchers.append(patching)
+                        if patching.attribute_name is not None:
+                            keywargs.update(arg)
+                        elif patching.new is DEFAULT:
+                            extra_args.append(arg)
+
+                    args += tuple(extra_args)
+                    return func(*args, **keywargs)
+                except:
+                    if (patching not in entered_patchers and
+                        _is_started(patching)):
+                        # the patcher may have been started, but an exception
+                        # raised whilst entering one of its additional_patchers
+                        entered_patchers.append(patching)
+                    # re-raise the exception
+                    raise
+            finally:
+                for patching in reversed(entered_patchers):
+                    patching.__exit__()
+
+        patched.patchings = [self]
+        if hasattr(func, 'func_code'):
+            # not in Python 3
+            patched.compat_co_firstlineno = getattr(
+                func, "compat_co_firstlineno",
+                func.func_code.co_firstlineno
+            )
+        return patched
+
+
+    def get_original(self):
+        target = self.getter()
+        name = self.attribute
+
+        original = DEFAULT
+        local = False
+
+        try:
+            original = target.__dict__[name]
+        except (AttributeError, KeyError):
+            original = getattr(target, name, DEFAULT)
+        else:
+            local = True
+
+        if not self.create and original is DEFAULT:
+            raise AttributeError(
+                "%s does not have the attribute %r" % (target, name)
+            )
+        return original, local
+
+
+    def __enter__(self):
+        """Perform the patch."""
+        new, spec, spec_set = self.new, self.spec, self.spec_set
+        autospec, kwargs = self.autospec, self.kwargs
+        new_callable = self.new_callable
+        self.target = self.getter()
+
+        original, local = self.get_original()
+
+        if new is DEFAULT and autospec is False:
+            inherit = False
+            if spec_set == True:
+                spec_set = original
+            elif spec == True:
+                # set spec to the object we are replacing
+                spec = original
+
+            if (spec or spec_set) is not None:
+                if isinstance(original, ClassTypes):
+                    # If we're patching out a class and there is a spec
+                    inherit = True
+
+            Klass = MagicMock
+            _kwargs = {}
+            if new_callable is not None:
+                Klass = new_callable
+            elif (spec or spec_set) is not None:
+                if not _callable(spec or spec_set):
+                    Klass = NonCallableMagicMock
+
+            if spec is not None:
+                _kwargs['spec'] = spec
+            if spec_set is not None:
+                _kwargs['spec_set'] = spec_set
+
+            # add a name to mocks
+            if (isinstance(Klass, type) and
+                issubclass(Klass, NonCallableMock) and self.attribute):
+                _kwargs['name'] = self.attribute
+
+            _kwargs.update(kwargs)
+            new = Klass(**_kwargs)
+
+            if inherit and _is_instance_mock(new):
+                # we can only tell if the instance should be callable if the
+                # spec is not a list
+                if (not _is_list(spec or spec_set) and not
+                    _instance_callable(spec or spec_set)):
+                    Klass = NonCallableMagicMock
+
+                _kwargs.pop('name')
+                new.return_value = Klass(_new_parent=new, _new_name='()',
+                                         **_kwargs)
+        elif autospec is not False:
+            # spec is ignored, new *must* be default, spec_set is treated
+            # as a boolean. Should we check spec is not None and that spec_set
+            # is a bool? mocksignature should also not be used. Should we
+            # check this?
+            if new is not DEFAULT:
+                raise TypeError(
+                    "autospec creates the mock for you. Can't specify "
+                    "autospec and new."
+                )
+            spec_set = bool(spec_set)
+            if autospec is True:
+                autospec = original
+
+            new = create_autospec(autospec, spec_set=spec_set,
+                                  _name=self.attribute, **kwargs)
+        elif kwargs:
+            # can't set keyword args when we aren't creating the mock
+            # XXXX If new is a Mock we could call new.configure_mock(**kwargs)
+            raise TypeError("Can't pass kwargs to a mock we aren't creating")
+
+        new_attr = new
+        if self.mocksignature:
+            new_attr = mocksignature(original, new)
+
+        self.temp_original = original
+        self.is_local = local
+        setattr(self.target, self.attribute, new_attr)
+        if self.attribute_name is not None:
+            extra_args = {}
+            if self.new is DEFAULT:
+                extra_args[self.attribute_name] =  new
+            for patching in self.additional_patchers:
+                arg = patching.__enter__()
+                if patching.new is DEFAULT:
+                    extra_args.update(arg)
+            return extra_args
+
+        return new
+
+
+    def __exit__(self, *_):
+        """Undo the patch."""
+        if not _is_started(self):
+            raise RuntimeError('stop called on unstarted patcher')
+
+        if self.is_local and self.temp_original is not DEFAULT:
+            setattr(self.target, self.attribute, self.temp_original)
+        else:
+            delattr(self.target, self.attribute)
+            if not self.create and not hasattr(self.target, self.attribute):
+                # needed for proxy objects like django settings
+                setattr(self.target, self.attribute, self.temp_original)
+
+        del self.temp_original
+        del self.is_local
+        del self.target
+        for patcher in reversed(self.additional_patchers):
+            if _is_started(patcher):
+                patcher.__exit__()
+
+    start = __enter__
+    stop = __exit__
+
+
+
+def _get_target(target):
+    try:
+        target, attribute = target.rsplit('.', 1)
+    except (TypeError, ValueError):
+        raise TypeError("Need a valid target to patch. You supplied: %r" %
+                        (target,))
+    getter = lambda: _importer(target)
+    return getter, attribute
+
+
+def _patch_object(
+        target, attribute, new=DEFAULT, spec=None,
+        create=False, mocksignature=False, spec_set=None, autospec=False,
+        new_callable=None, **kwargs
+    ):
+    """
+    patch.object(target, attribute, new=DEFAULT, spec=None, create=False,
+                 mocksignature=False, spec_set=None, autospec=False,
+                 new_callable=None, **kwargs)
+
+    patch the named member (`attribute`) on an object (`target`) with a mock
+    object.
+
+    `patch.object` can be used as a decorator, class decorator or a context
+    manager. Arguments `new`, `spec`, `create`, `mocksignature`, `spec_set`,
+    `autospec` and `new_callable` have the same meaning as for `patch`. Like
+    `patch`, `patch.object` takes arbitrary keyword arguments for configuring
+    the mock object it creates.
+
+    When used as a class decorator `patch.object` honours `patch.TEST_PREFIX`
+    for choosing which methods to wrap.
+    """
+    getter = lambda: target
+    return _patch(
+        getter, attribute, new, spec, create, mocksignature,
+        spec_set, autospec, new_callable, kwargs
+    )
+
+
+def _patch_multiple(target, spec=None, create=False,
+        mocksignature=False, spec_set=None, autospec=False,
+        new_callable=None, **kwargs
+    ):
+    """Perform multiple patches in a single call. It takes the object to be
+    patched (either as an object or a string to fetch the object by importing)
+    and keyword arguments for the patches::
+
+        with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):
+            ...
+
+    Use `DEFAULT` as the value if you want `patch.multiple` to create
+    mocks for you. In this case the created mocks are passed into a decorated
+    function by keyword, and a dictionary is returned when `patch.multiple` is
+    used as a context manager.
+
+    `patch.multiple` can be used as a decorator, class decorator or a context
+    manager. The arguments `spec`, `spec_set`, `create`, `mocksignature`,
+    `autospec` and `new_callable` have the same meaning as for `patch`. These
+    arguments will be applied to *all* patches done by `patch.multiple`.
+
+    When used as a class decorator `patch.multiple` honours `patch.TEST_PREFIX`
+    for choosing which methods to wrap.
+    """
+    if type(target) in (unicode, str):
+        getter = lambda: _importer(target)
+    else:
+        getter = lambda: target
+
+    if not kwargs:
+        raise ValueError(
+            'Must supply at least one keyword argument with patch.multiple'
+        )
+    # need to wrap in a list for python 3, where items is a view
+    items = list(kwargs.items())
+    attribute, new = items[0]
+    patcher = _patch(
+        getter, attribute, new, spec, create, mocksignature, spec_set,
+        autospec, new_callable, {}
+    )
+    patcher.attribute_name = attribute
+    for attribute, new in items[1:]:
+        this_patcher = _patch(
+            getter, attribute, new, spec, create, mocksignature, spec_set,
+            autospec, new_callable, {}
+        )
+        this_patcher.attribute_name = attribute
+        patcher.additional_patchers.append(this_patcher)
+    return patcher
+
+
+def patch(
+        target, new=DEFAULT, spec=None, create=False,
+        mocksignature=False, spec_set=None, autospec=False,
+        new_callable=None, **kwargs
+    ):
+    """
+    `patch` acts as a function decorator, class decorator or a context
+    manager. Inside the body of the function or with statement, the `target`
+    (specified in the form `'package.module.ClassName'`) is patched
+    with a `new` object. When the function/with statement exits the patch is
+    undone.
+
+    The `target` is imported and the specified attribute patched with the new
+    object, so it must be importable from the environment you are calling the
+    decorator from. The target is imported when the decorated function is
+    executed, not at decoration time.
+
+    If `new` is omitted, then a new `MagicMock` is created and passed in as an
+    extra argument to the decorated function.
+
+    The `spec` and `spec_set` keyword arguments are passed to the `MagicMock`
+    if patch is creating one for you.
+
+    In addition you can pass `spec=True` or `spec_set=True`, which causes
+    patch to pass in the object being mocked as the spec/spec_set object.
+
+    `new_callable` allows you to specify a different class, or callable object,
+    that will be called to create the `new` object. By default `MagicMock` is
+    used.
+
+    A more powerful form of `spec` is `autospec`. If you set `autospec=True`
+    then the mock with be created with a spec from the object being replaced.
+    All attributes of the mock will also have the spec of the corresponding
+    attribute of the object being replaced. Methods and functions being mocked
+    will have their arguments checked and will raise a `TypeError` if they are
+    called with the wrong signature (similar to `mocksignature`). For mocks
+    replacing a class, their return value (the 'instance') will have the same
+    spec as the class.
+
+    Instead of `autospec=True` you can pass `autospec=some_object` to use an
+    arbitrary object as the spec instead of the one being replaced.
+
+    If `mocksignature` is True then the patch will be done with a function
+    created by mocking the one being replaced. If the object being replaced is
+    a class then the signature of `__init__` will be copied. If the object
+    being replaced is a callable object then the signature of `__call__` will
+    be copied.
+
+    By default `patch` will fail to replace attributes that don't exist. If
+    you pass in `create=True`, and the attribute doesn't exist, patch will
+    create the attribute for you when the patched function is called, and
+    delete it again afterwards. This is useful for writing tests against
+    attributes that your production code creates at runtime. It is off by by
+    default because it can be dangerous. With it switched on you can write
+    passing tests against APIs that don't actually exist!
+
+    Patch can be used as a `TestCase` class decorator. It works by
+    decorating each test method in the class. This reduces the boilerplate
+    code when your test methods share a common patchings set. `patch` finds
+    tests by looking for method names that start with `patch.TEST_PREFIX`.
+    By default this is `test`, which matches the way `unittest` finds tests.
+    You can specify an alternative prefix by setting `patch.TEST_PREFIX`.
+
+    Patch can be used as a context manager, with the with statement. Here the
+    patching applies to the indented block after the with statement. If you
+    use "as" then the patched object will be bound to the name after the
+    "as"; very useful if `patch` is creating a mock object for you.
+
+    `patch` takes arbitrary keyword arguments. These will be passed to
+    the `Mock` (or `new_callable`) on construction.
+
+    `patch.dict(...)`, `patch.multiple(...)` and `patch.object(...)` are
+    available for alternate use-cases.
+    """
+    getter, attribute = _get_target(target)
+    return _patch(
+        getter, attribute, new, spec, create, mocksignature,
+        spec_set, autospec, new_callable, kwargs
+    )
+
+
+class _patch_dict(object):
+    """
+    Patch a dictionary, or dictionary like object, and restore the dictionary
+    to its original state after the test.
+
+    `in_dict` can be a dictionary or a mapping like container. If it is a
+    mapping then it must at least support getting, setting and deleting items
+    plus iterating over keys.
+
+    `in_dict` can also be a string specifying the name of the dictionary, which
+    will then be fetched by importing it.
+
+    `values` can be a dictionary of values to set in the dictionary. `values`
+    can also be an iterable of `(key, value)` pairs.
+
+    If `clear` is True then the dictionary will be cleared before the new
+    values are set.
+
+    `patch.dict` can also be called with arbitrary keyword arguments to set
+    values in the dictionary::
+
+        with patch.dict('sys.modules', mymodule=Mock(), other_module=Mock()):
+            ...
+
+    `patch.dict` can be used as a context manager, decorator or class
+    decorator. When used as a class decorator `patch.dict` honours
+    `patch.TEST_PREFIX` for choosing which methods to wrap.
+    """
+
+    def __init__(self, in_dict, values=(), clear=False, **kwargs):
+        if isinstance(in_dict, basestring):
+            in_dict = _importer(in_dict)
+        self.in_dict = in_dict
+        # support any argument supported by dict(...) constructor
+        self.values = dict(values)
+        self.values.update(kwargs)
+        self.clear = clear
+        self._original = None
+
+
+    def __call__(self, f):
+        if isinstance(f, ClassTypes):
+            return self.decorate_class(f)
+        @wraps(f)
+        def _inner(*args, **kw):
+            self._patch_dict()
+            try:
+                return f(*args, **kw)
+            finally:
+                self._unpatch_dict()
+
+        return _inner
+
+
+    def decorate_class(self, klass):
+        for attr in dir(klass):
+            attr_value = getattr(klass, attr)
+            if (attr.startswith(patch.TEST_PREFIX) and
+                 hasattr(attr_value, "__call__")):
+                decorator = _patch_dict(self.in_dict, self.values, self.clear)
+                decorated = decorator(attr_value)
+                setattr(klass, attr, decorated)
+        return klass
+
+
+    def __enter__(self):
+        """Patch the dict."""
+        self._patch_dict()
+
+
+    def _patch_dict(self):
+        values = self.values
+        in_dict = self.in_dict
+        clear = self.clear
+
+        try:
+            original = in_dict.copy()
+        except AttributeError:
+            # dict like object with no copy method
+            # must support iteration over keys
+            original = {}
+            for key in in_dict:
+                original[key] = in_dict[key]
+        self._original = original
+
+        if clear:
+            _clear_dict(in_dict)
+
+        try:
+            in_dict.update(values)
+        except AttributeError:
+            # dict like object with no update method
+            for key in values:
+                in_dict[key] = values[key]
+
+
+    def _unpatch_dict(self):
+        in_dict = self.in_dict
+        original = self._original
+
+        _clear_dict(in_dict)
+
+        try:
+            in_dict.update(original)
+        except AttributeError:
+            for key in original:
+                in_dict[key] = original[key]
+
+
+    def __exit__(self, *args):
+        """Unpatch the dict."""
+        self._unpatch_dict()
+        return False
+
+    start = __enter__
+    stop = __exit__
+
+
+def _clear_dict(in_dict):
+    try:
+        in_dict.clear()
+    except AttributeError:
+        keys = list(in_dict)
+        for key in keys:
+            del in_dict[key]
+
+
+patch.object = _patch_object
+patch.dict = _patch_dict
+patch.multiple = _patch_multiple
+patch.TEST_PREFIX = 'test'
+
+magic_methods = (
+    "lt le gt ge eq ne "
+    "getitem setitem delitem "
+    "len contains iter "
+    "hash str sizeof "
+    "enter exit "
+    "divmod neg pos abs invert "
+    "complex int float index "
+    "trunc floor ceil "
+)
+
+numerics = "add sub mul div floordiv mod lshift rshift and xor or pow "
+inplace = ' '.join('i%s' % n for n in numerics.split())
+right = ' '.join('r%s' % n for n in numerics.split())
+extra = ''
+if inPy3k:
+    extra = 'bool next '
+else:
+    extra = 'unicode long nonzero oct hex truediv rtruediv '
+
+# not including __prepare__, __instancecheck__, __subclasscheck__
+# (as they are metaclass methods)
+# __del__ is not supported at all as it causes problems if it exists
+
+_non_defaults = set('__%s__' % method for method in [
+    'cmp', 'getslice', 'setslice', 'coerce', 'subclasses',
+    'format', 'get', 'set', 'delete', 'reversed',
+    'missing', 'reduce', 'reduce_ex', 'getinitargs',
+    'getnewargs', 'getstate', 'setstate', 'getformat',
+    'setformat', 'repr', 'dir'
+])
+
+
+def _get_method(name, func):
+    "Turns a callable object (like a mock) into a real function"
+    def method(self, *args, **kw):
+        return func(self, *args, **kw)
+    method.__name__ = name
+    return method
+
+
+_magics = set(
+    '__%s__' % method for method in
+    ' '.join([magic_methods, numerics, inplace, right, extra]).split()
+)
+
+_all_magics = _magics | _non_defaults
+
+_unsupported_magics = set([
+    '__getattr__', '__setattr__',
+    '__init__', '__new__', '__prepare__'
+    '__instancecheck__', '__subclasscheck__',
+    '__del__'
+])
+
+_calculate_return_value = {
+    '__hash__': lambda self: object.__hash__(self),
+    '__str__': lambda self: object.__str__(self),
+    '__sizeof__': lambda self: object.__sizeof__(self),
+    '__unicode__': lambda self: unicode(object.__str__(self)),
+}
+
+_return_values = {
+    '__int__': 1,
+    '__contains__': False,
+    '__len__': 0,
+    '__exit__': False,
+    '__complex__': 1j,
+    '__float__': 1.0,
+    '__bool__': True,
+    '__nonzero__': True,
+    '__oct__': '1',
+    '__hex__': '0x1',
+    '__long__': long(1),
+    '__index__': 1,
+}
+
+
+def _get_eq(self):
+    def __eq__(other):
+        ret_val = self.__eq__._mock_return_value
+        if ret_val is not DEFAULT:
+            return ret_val
+        return self is other
+    return __eq__
+
+def _get_ne(self):
+    def __ne__(other):
+        if self.__ne__._mock_return_value is not DEFAULT:
+            return DEFAULT
+        return self is not other
+    return __ne__
+
+def _get_iter(self):
+    def __iter__():
+        ret_val = self.__iter__._mock_return_value
+        if ret_val is DEFAULT:
+            return iter([])
+        # if ret_val was already an iterator, then calling iter on it should
+        # return the iterator unchanged
+        return iter(ret_val)
+    return __iter__
+
+_side_effect_methods = {
+    '__eq__': _get_eq,
+    '__ne__': _get_ne,
+    '__iter__': _get_iter,
+}
+
+
+
+def _set_return_value(mock, method, name):
+    fixed = _return_values.get(name, DEFAULT)
+    if fixed is not DEFAULT:
+        method.return_value = fixed
+        return
+
+    return_calulator = _calculate_return_value.get(name)
+    if return_calulator is not None:
+        try:
+            return_value = return_calulator(mock)
+        except AttributeError:
+            # XXXX why do we return AttributeError here?
+            #      set it as a side_effect instead?
+            return_value = AttributeError(name)
+        method.return_value = return_value
+        return
+
+    side_effector = _side_effect_methods.get(name)
+    if side_effector is not None:
+        method.side_effect = side_effector(mock)
+
+
+
+class MagicMixin(object):
+    def __init__(self, *args, **kw):
+        _super(MagicMixin, self).__init__(*args, **kw)
+        self._mock_set_magics()
+
+
+    def _mock_set_magics(self):
+        these_magics = _magics
+
+        if self._mock_methods is not None:
+            these_magics = _magics.intersection(self._mock_methods)
+
+            remove_magics = set()
+            remove_magics = _magics - these_magics
+
+            for entry in remove_magics:
+                if entry in type(self).__dict__:
+                    # remove unneeded magic methods
+                    delattr(self, entry)
+
+        # don't overwrite existing attributes if called a second time
+        these_magics = these_magics - set(type(self).__dict__)
+
+        _type = type(self)
+        for entry in these_magics:
+            setattr(_type, entry, MagicProxy(entry, self))
+
+
+
+class NonCallableMagicMock(MagicMixin, NonCallableMock):
+    """A version of `MagicMock` that isn't callable."""
+    def mock_add_spec(self, spec, spec_set=False):
+        """Add a spec to a mock. `spec` can either be an object or a
+        list of strings. Only attributes on the `spec` can be fetched as
+        attributes from the mock.
+
+        If `spec_set` is True then only attributes on the spec can be set."""
+        self._mock_add_spec(spec, spec_set)
+        self._mock_set_magics()
+
+
+
+class MagicMock(MagicMixin, Mock):
+    """
+    MagicMock is a subclass of Mock with default implementations
+    of most of the magic methods. You can use MagicMock without having to
+    configure the magic methods yourself.
+
+    If you use the `spec` or `spec_set` arguments then *only* magic
+    methods that exist in the spec will be created.
+
+    Attributes and the return value of a `MagicMock` will also be `MagicMocks`.
+    """
+    def mock_add_spec(self, spec, spec_set=False):
+        """Add a spec to a mock. `spec` can either be an object or a
+        list of strings. Only attributes on the `spec` can be fetched as
+        attributes from the mock.
+
+        If `spec_set` is True then only attributes on the spec can be set."""
+        self._mock_add_spec(spec, spec_set)
+        self._mock_set_magics()
+
+
+
+class MagicProxy(object):
+    def __init__(self, name, parent):
+        self.name = name
+        self.parent = parent
+
+    def __call__(self, *args, **kwargs):
+        m = self.create_mock()
+        return m(*args, **kwargs)
+
+    def create_mock(self):
+        entry = self.name
+        parent = self.parent
+        m = parent._get_child_mock(name=entry, _new_name=entry,
+                                   _new_parent=parent)
+        setattr(parent, entry, m)
+        _set_return_value(parent, m, entry)
+        return m
+
+    def __get__(self, obj, _type=None):
+        return self.create_mock()
+
+
+
+class _ANY(object):
+    "A helper object that compares equal to everything."
+
+    def __eq__(self, other):
+        return True
+
+    def __ne__(self, other):
+        return False
+
+    def __repr__(self):
+        return '<ANY>'
+
+ANY = _ANY()
+
+
+
+def _format_call_signature(name, args, kwargs):
+    message = '%s(%%s)' % name
+    formatted_args = ''
+    args_string = ', '.join([repr(arg) for arg in args])
+    kwargs_string = ', '.join([
+        '%s=%r' % (key, value) for key, value in kwargs.items()
+    ])
+    if args_string:
+        formatted_args = args_string
+    if kwargs_string:
+        if formatted_args:
+            formatted_args += ', '
+        formatted_args += kwargs_string
+
+    return message % formatted_args
+
+
+
+class _Call(tuple):
+    """
+    A tuple for holding the results of a call to a mock, either in the form
+    `(args, kwargs)` or `(name, args, kwargs)`.
+
+    If args or kwargs are empty then a call tuple will compare equal to
+    a tuple without those values. This makes comparisons less verbose::
+
+        _Call(('name', (), {})) == ('name',)
+        _Call(('name', (1,), {})) == ('name', (1,))
+        _Call(((), {'a': 'b'})) == ({'a': 'b'},)
+
+    The `_Call` object provides a useful shortcut for comparing with call::
+
+        _Call(((1, 2), {'a': 3})) == call(1, 2, a=3)
+        _Call(('foo', (1, 2), {'a': 3})) == call.foo(1, 2, a=3)
+
+    If the _Call has no name then it will match any name.
+    """
+    def __new__(cls, value=(), name=None, parent=None, two=False,
+                from_kall=True):
+        name = ''
+        args = ()
+        kwargs = {}
+        _len = len(value)
+        if _len == 3:
+            name, args, kwargs = value
+        elif _len == 2:
+            first, second = value
+            if isinstance(first, basestring):
+                name = first
+                if isinstance(second, tuple):
+                    args = second
+                else:
+                    kwargs = second
+            else:
+                args, kwargs = first, second
+        elif _len == 1:
+            value, = value
+            if isinstance(value, basestring):
+                name = value
+            elif isinstance(value, tuple):
+                args = value
+            else:
+                kwargs = value
+
+        if two:
+            return tuple.__new__(cls, (args, kwargs))
+
+        return tuple.__new__(cls, (name, args, kwargs))
+
+
+    def __init__(self, value=(), name=None, parent=None, two=False,
+                 from_kall=True):
+        self.name = name
+        self.parent = parent
+        self.from_kall = from_kall
+
+
+    def __eq__(self, other):
+        if other is ANY:
+            return True
+        try:
+            len_other = len(other)
+        except TypeError:
+            return False
+
+        self_name = ''
+        if len(self) == 2:
+            self_args, self_kwargs = self
+        else:
+            self_name, self_args, self_kwargs = self
+
+        other_name = ''
+        if len_other == 0:
+            other_args, other_kwargs = (), {}
+        elif len_other == 3:
+            other_name, other_args, other_kwargs = other
+        elif len_other == 1:
+            value, = other
+            if isinstance(value, tuple):
+                other_args = value
+                other_kwargs = {}
+            elif isinstance(value, basestring):
+                other_name = value
+                other_args, other_kwargs = (), {}
+            else:
+                other_args = ()
+                other_kwargs = value
+        else:
+            # len 2
+            # could be (name, args) or (name, kwargs) or (args, kwargs)
+            first, second = other
+            if isinstance(first, basestring):
+                other_name = first
+                if isinstance(second, tuple):
+                    other_args, other_kwargs = second, {}
+                else:
+                    other_args, other_kwargs = (), second
+            else:
+                other_args, other_kwargs = first, second
+
+        if self_name and other_name != self_name:
+            return False
+
+        # this order is important for ANY to work!
+        return (other_args, other_kwargs) == (self_args, self_kwargs)
+
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+    def __call__(self, *args, **kwargs):
+        if self.name is None:
+            return _Call(('', args, kwargs), name='()')
+
+        name = self.name + '()'
+        return _Call((self.name, args, kwargs), name=name, parent=self)
+
+
+    def __getattr__(self, attr):
+        if self.name is None:
+            return _Call(name=attr, from_kall=False)
+        name = '%s.%s' % (self.name, attr)
+        return _Call(name=name, parent=self, from_kall=False)
+
+
+    def __repr__(self):
+        if not self.from_kall:
+            name = self.name or 'call'
+            if name.startswith('()'):
+                name = 'call%s' % name
+            return name
+
+        if len(self) == 2:
+            name = 'call'
+            args, kwargs = self
+        else:
+            name, args, kwargs = self
+            if not name:
+                name = 'call'
+            elif not name.startswith('()'):
+                name = 'call.%s' % name
+            else:
+                name = 'call%s' % name
+        return _format_call_signature(name, args, kwargs)
+
+
+    def call_list(self):
+        """For a call object that represents multiple calls, `call_list`
+        returns a list of all the intermediate calls as well as the
+        final call."""
+        vals = []
+        thing = self
+        while thing is not None:
+            if thing.from_kall:
+                vals.append(thing)
+            thing = thing.parent
+        return _CallList(reversed(vals))
+
+
+call = _Call(from_kall=False)
+
+
+
+def create_autospec(spec, spec_set=False, instance=False, _parent=None,
+                    _name=None, **kwargs):
+    """Create a mock object using another object as a spec. Attributes on the
+    mock will use the corresponding attribute on the `spec` object as their
+    spec.
+
+    Functions or methods being mocked will have their arguments checked in a
+    similar way to `mocksignature` to check that they are called with the
+    correct signature.
+
+    If `spec_set` is True then attempting to set attributes that don't exist
+    on the spec object will raise an `AttributeError`.
+
+    If a class is used as a spec then the return value of the mock (the
+    instance of the class) will have the same spec. You can use a class as the
+    spec for an instance object by passing `instance=True`. The returned mock
+    will only be callable if instances of the mock are callable.
+
+    `create_autospec` also takes arbitrary keyword arguments that are passed to
+    the constructor of the created mock."""
+    if _is_list(spec):
+        # can't pass a list instance to the mock constructor as it will be
+        # interpreted as a list of strings
+        spec = type(spec)
+
+    is_type = isinstance(spec, ClassTypes)
+
+    _kwargs = {'spec': spec}
+    if spec_set:
+        _kwargs = {'spec_set': spec}
+    elif spec is None:
+        # None we mock with a normal mock without a spec
+        _kwargs = {}
+
+    _kwargs.update(kwargs)
+
+    Klass = MagicMock
+    if type(spec) in DescriptorTypes:
+        # descriptors don't have a spec
+        # because we don't know what type they return
+        _kwargs = {}
+    elif not _callable(spec):
+        Klass = NonCallableMagicMock
+    elif is_type and instance and not _instance_callable(spec):
+        Klass = NonCallableMagicMock
+
+    _new_name = _name
+    if _parent is None:
+        # for a top level object no _new_name should be set
+        _new_name = ''
+
+    mock = Klass(parent=_parent, _new_parent=_parent, _new_name=_new_name,
+                 name=_name, **_kwargs)
+
+    if isinstance(spec, FunctionTypes):
+        # should only happen at the top level because we don't
+        # recurse for functions
+        mock = _set_signature(mock, spec)
+    else:
+        _check_signature(spec, mock, is_type, instance)
+
+    if _parent is not None and not instance:
+        _parent._mock_children[_name] = mock
+
+    if is_type and not instance and 'return_value' not in kwargs:
+        # XXXX could give a name to the return_value mock?
+        mock.return_value = create_autospec(spec, spec_set, instance=True,
+                                            _name='()', _parent=mock)
+
+    for entry in dir(spec):
+        if _is_magic(entry):
+            # MagicMock already does the useful magic methods for us
+            continue
+
+        if isinstance(spec, FunctionTypes) and entry in FunctionAttributes:
+            # allow a mock to actually be a function from mocksignature
+            continue
+
+        # XXXX do we need a better way of getting attributes without
+        # triggering code execution (?) Probably not - we need the actual
+        # object to mock it so we would rather trigger a property than mock
+        # the property descriptor. Likewise we want to mock out dynamically
+        # provided attributes.
+        # XXXX what about attributes that raise exceptions on being fetched
+        # we could be resilient against it, or catch and propagate the
+        # exception when the attribute is fetched from the mock
+        original = getattr(spec, entry)
+
+        kwargs = {'spec': original}
+        if spec_set:
+            kwargs = {'spec_set': original}
+
+        if not isinstance(original, FunctionTypes):
+            new = _SpecState(original, spec_set, mock, entry, instance)
+            mock._mock_children[entry] = new
+        else:
+            parent = mock
+            if isinstance(spec, FunctionTypes):
+                parent = mock.mock
+
+            new = MagicMock(parent=parent, name=entry, _new_name=entry,
+                            _new_parent=parent, **kwargs)
+            mock._mock_children[entry] = new
+            skipfirst = _must_skip(spec, entry, is_type)
+            _check_signature(original, new, skipfirst=skipfirst)
+
+        # so functions created with mocksignature become instance attributes,
+        # *plus* their underlying mock exists in _mock_children of the parent
+        # mock. Adding to _mock_children may be unnecessary where we are also
+        # setting as an instance attribute?
+        if isinstance(new, FunctionTypes):
+            setattr(mock, entry, new)
+
+    return mock
+
+
+def _must_skip(spec, entry, is_type):
+    if not isinstance(spec, ClassTypes):
+        if entry in getattr(spec, '__dict__', {}):
+            # instance attribute - shouldn't skip
+            return False
+        # can't use type because of old style classes
+        spec = spec.__class__
+    if not hasattr(spec, '__mro__'):
+        # old style class: can't have descriptors anyway
+        return is_type
+
+    for klass in spec.__mro__:
+        result = klass.__dict__.get(entry, DEFAULT)
+        if result is DEFAULT:
+            continue
+        if isinstance(result, (staticmethod, classmethod)):
+            return False
+        return is_type
+
+    # shouldn't get here unless function is a dynamically provided attribute
+    # XXXX untested behaviour
+    return is_type
+
+
+def _get_class(obj):
+    try:
+        return obj.__class__
+    except AttributeError:
+        # in Python 2, _sre.SRE_Pattern objects have no __class__
+        return type(obj)
+
+
+class _SpecState(object):
+
+    def __init__(self, spec, spec_set=False, parent=None,
+                 name=None, ids=None, instance=False):
+        self.spec = spec
+        self.ids = ids
+        self.spec_set = spec_set
+        self.parent = parent
+        self.instance = instance
+        self.name = name
+
+
+FunctionTypes = (
+    # python function
+    type(create_autospec),
+    # instance method
+    type(ANY.__eq__),
+    # unbound method
+    type(_ANY.__eq__),
+)
+
+FunctionAttributes = set([
+    'func_closure',
+    'func_code',
+    'func_defaults',
+    'func_dict',
+    'func_doc',
+    'func_globals',
+    'func_name',
+])
diff --git a/script/test/diffcalc (copy)/model/README.txt b/script/test/diffcalc (copy)/model/README.txt
new file mode 100644
index 0000000..45d8fcb
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/README.txt	
@@ -0,0 +1,13 @@
+Setting up the sixc vrml model to work via Epics pv's from b16's simulation running on the office network.
+
+
+1. Synoptic
+$ launcher --port 6064
+
+2. Shell
+export EPICS_CA_REPEATER_PORT=6065
+export EPICS_CA_SERVER_PORT=6064
+
+3. Vrml viewer
+export EPICS_CA_SERVER_PORT=6064
+dls-vrml-epics-viewer.py fivec.wrl fivec.wcfg
diff --git a/script/test/diffcalc (copy)/model/fivec.fxw b/script/test/diffcalc (copy)/model/fivec.fxw
new file mode 100644
index 0000000..de9ae05
Binary files /dev/null and b/script/test/diffcalc (copy)/model/fivec.fxw differ
diff --git a/script/test/diffcalc (copy)/model/fivec.wcfg b/script/test/diffcalc (copy)/model/fivec.wcfg
new file mode 100644
index 0000000..8f96e1e
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/fivec.wcfg	
@@ -0,0 +1,5 @@
+dad_alpha_frame	rotation	pv["DIFFSIM:FIVEC:ALPHA.RBV"]
+dad_delta_frame	rotation	pv["DIFFSIM:FIVEC:DELTA.RBV"]
+dad_omega_frame	rotation	pv["DIFFSIM:FIVEC:OMEGA.RBV"]
+dad_chi_frame	rotation	pv["DIFFSIM:FIVEC:CHI.RBV"]
+dad_phi_frame	rotation	pv["DIFFSIM:FIVEC:PHI.RBV"]
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/model/fivec.wrl b/script/test/diffcalc (copy)/model/fivec.wrl
new file mode 100644
index 0000000..85f6fad
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/fivec.wrl	
@@ -0,0 +1,1011 @@
+#VRML V2.0 utf8
+WorldInfo {
+ title "fourc"
+ info ["This Web3D Content was created with Flux Studio, a Web3D authoring tool"
+ "www.mediamachines.com"
+ "This Web3D Content was created with Flux Studio, a Web3D authoring tool"]
+}
+## Vizthumbnail  Thumb_fivec_wrl5688291255594457.jpg
+DirectionalLight {
+ intensity 1.000
+ ambientIntensity 0.500
+ direction -.621 -.23944 -.74634
+ color 1 1 1
+ on TRUE
+}
+DirectionalLight {
+ intensity 1.000
+ ambientIntensity 0.000
+ direction -.01373 -.46642 -.88446
+ color 1 1 1
+ on TRUE
+}
+DEF lab_x Shape {
+ appearance Appearance {
+  material DEF Rust Material {
+   ambientIntensity 0.200
+   shininess 0.200
+   diffuseColor .50196 .50196 .50196
+  }
+ }
+ geometry DEF GeoCylinder15 Cylinder {
+  height 60.000
+  radius 0.020
+ }
+}
+DEF dad_lab_z Transform {
+ rotation 1 0 0 1.571
+ children [
+  DEF lab_z Shape {
+   appearance Appearance {
+    material USE Rust
+   }
+   geometry DEF GeoCylinder17 Cylinder {
+    height 40.000
+    radius 0.020
+   }
+  }
+ ]
+}
+DEF dad_lab_beam Transform {
+ translation 10 0 0
+ rotation 0 0 1 1.571
+ children [
+  DEF lab_beam Shape {
+   appearance Appearance {
+    material DEF White Material {
+     ambientIntensity 0.500
+     shininess 0.100
+     transparency 0.500
+     diffuseColor 1 1 1
+     emissiveColor 1 1 1
+    }
+   }
+   geometry DEF GeoCylinder20 Cylinder {
+    height 20.000
+    radius 0.050
+   }
+  }
+ ]
+}
+DEF dad_lab_beam0 Transform {
+ translation 20 0 0
+ rotation 0 0 1 1.571
+ children [
+  DEF lab_beam0 Shape {
+   appearance Appearance {
+    material DEF Shiny_Black Material {
+     ambientIntensity 0.200
+     shininess 0.100
+     diffuseColor 1 1 1
+    }
+   }
+   geometry DEF GeoCylinder22 Cylinder {
+    height 4.000
+    radius 0.200
+   }
+  }
+ ]
+}
+DEF dad_Cone2 Transform {
+ translation 17.5 0 0
+ rotation 0 0 1 1.571
+ children [
+  DEF Cone2 Shape {
+   appearance Appearance {
+    material USE Shiny_Black
+   }
+   geometry DEF GeoCone2 Cone {
+    height 1.500
+    bottomRadius 0.500
+   }
+  }
+ ]
+}
+DEF dad_lab_y Transform {
+ rotation 0 0 -1 1.571
+ children [
+  DEF lab_y Shape {
+   appearance Appearance {
+    material USE Rust
+   }
+   geometry DEF GeoCylinder16 Cylinder {
+    height 60.000
+    radius 0.020
+   }
+  }
+ ]
+}
+DEF dad_alpha_frame Transform {
+ rotation 0 1 0 +.349
+ children [
+  DEF dad_alpha_base Transform {
+   translation 0 -20.5 0
+   children [
+    DEF alpha_base Shape {
+     appearance Appearance {
+      material DEF Red Material {
+       ambientIntensity 0.200
+       shininess 0.200
+       diffuseColor .50196 0 0
+      }
+     }
+     geometry DEF GeoCylinder1 Cylinder {
+      height 2.000
+      radius 6.000
+     }
+    }
+   ]
+  }
+  DEF dad_lab_post Transform {
+   translation 0 -10 -11
+   children [
+    DEF alpha_post Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox1 Box {
+      size 4 20 1
+     }
+    }
+   ]
+  }
+  DEF dad_omega_frame Transform {
+   rotation 0 0 1 -.349
+   children [
+    DEF dad_chi_frame Transform {
+     rotation 1 0 0 -.785
+     children [
+      DEF dad_phi_frame Transform {
+       rotation 0 0 1 -.349
+       children [
+        DEF dad_Cylinder7 Transform {
+         translation 0 0 -4
+         rotation 1 0 0 1.571
+         children [
+          DEF Cylinder7 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoCylinder7 Cylinder {
+            height 2.000
+            radius 1.000
+           }
+          }
+         ]
+        }
+        DEF dad_Cylinder8 Transform {
+         translation 0 0 -3.5
+         rotation 1 0 0 1.571
+         children [
+          DEF Cylinder8 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoCylinder8 Cylinder {
+            height 6.000
+            radius 0.250
+           }
+          }
+         ]
+        }
+        DEF Box3 Shape {
+         appearance Appearance {
+          material USE White
+         }
+         geometry DEF GeoBox3 Box {
+          size 1 1 1
+         }
+        }
+        DEF dad_Box11 Transform {
+         translation 0 1 -4
+         children [
+          DEF Box11 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoBox11 Box {
+            size .25 .5 2
+           }
+          }
+         ]
+        }
+        DEF Box4 Shape {
+         appearance Appearance {
+          material DEF White_wire Material {
+           emissiveColor 1 1 1
+          }
+         }
+         geometry IndexedLineSet {
+          coordIndex [
+            0 1 2 0 
+            -1 0 2 3 
+            0 -1 1 5 
+            6 1 -1 1 
+            6 2 1 -1 
+            2 6 7 2 
+            -1 2 7 3 
+            2 -1 3 7 
+            4 3 -1 3 
+            4 0 3 -1 
+            0 4 5 0 
+            -1 0 5 1 
+            0 -1 6 5 
+            4 6 -1 6 
+            4 7 6 -1 
+          ]
+          coord Coordinate {
+           point [
+            -.5 .5 -.5
+            -.5 .5 .5
+            .5 .5 .5
+            .5 .5 -.5
+            -.5 -.5 -.5
+            -.5 -.5 .5
+            .5 -.5 .5
+            .5 -.5 -.5
+           ]
+          }
+         }
+        }
+       ]
+      }
+      DEF dad_Box2 Transform {
+       translation 0 0 -5.5
+       children [
+        DEF Box2 Shape {
+         appearance Appearance {
+          material DEF Purple Material {
+           ambientIntensity 0.200
+           shininess 0.200
+           diffuseColor .9176 0 .874
+          }
+         }
+         geometry DEF GeoBox2 Box {
+          size 2.8 2.8 1.5
+         }
+        }
+       ]
+      }
+      DEF dad_Box6 Transform {
+       translation 0 1.25 -5.5
+       children [
+        DEF Box6 Shape {
+         appearance Appearance {
+          material USE Purple
+         }
+         geometry DEF GeoBox21 Box {
+          size .25 1 1.5
+         }
+        }
+       ]
+      }
+     ]
+    }
+    DEF dad_Cylinder2 Transform {
+     rotation 0 0 1 1.571
+     scale 1.1 1.5 1.1
+     children [
+      DEF Cylinder2 Shape {
+       appearance Appearance {
+        material DEF Green Material {
+         ambientIntensity 0.200
+         shininess 0.200
+         diffuseColor .00784 .65098 .02353
+        }
+       }
+       geometry DEF Cylinder2_Geo IndexedFaceSet {
+        creaseAngle 0.524
+        coordIndex [
+          49 50 48 -1 
+          48 50 51 -1 
+          48 51 47 -1 
+          47 51 20 -1 
+          47 20 21 -1 
+          12 13 56 -1 
+          56 13 14 -1 
+          56 14 55 -1 
+          55 14 15 -1 
+          55 15 54 -1 
+          54 15 16 -1 
+          54 16 53 -1 
+          53 16 17 -1 
+          53 17 52 -1 
+          52 17 18 -1 
+          52 18 51 -1 
+          51 18 19 -1 
+          51 19 20 -1 
+          5 6 62 -1 
+          62 6 7 -1 
+          62 7 61 -1 
+          61 7 8 -1 
+          61 8 60 -1 
+          60 8 9 -1 
+          60 9 59 -1 
+          59 9 10 -1 
+          59 10 58 -1 
+          58 10 11 -1 
+          58 11 57 -1 
+          57 11 12 -1 
+          57 12 56 -1 
+          5 63 4 -1 
+          4 63 64 -1 
+          4 64 3 -1 
+          3 64 1 -1 
+          3 1 2 -1 
+          2 1 35 -1 
+          2 35 36 -1 
+          28 41 27 -1 
+          27 41 42 -1 
+          27 42 26 -1 
+          26 42 43 -1 
+          26 43 25 -1 
+          25 43 44 -1 
+          25 44 24 -1 
+          24 44 45 -1 
+          24 45 23 -1 
+          23 45 46 -1 
+          23 46 22 -1 
+          22 46 47 -1 
+          22 47 21 -1 
+          34 36 33 -1 
+          33 36 37 -1 
+          33 37 32 -1 
+          32 37 38 -1 
+          32 38 31 -1 
+          31 38 39 -1 
+          31 39 30 -1 
+          30 39 40 -1 
+          30 40 29 -1 
+          29 40 41 -1 
+          29 41 28 -1 
+          1 64 0 -1 
+          2 36 34 -1 
+          63 5 62 -1 
+          95 96 97 -1 
+          97 96 65 -1 
+          97 65 129 -1 
+          129 65 66 -1 
+          129 66 128 -1 
+          128 66 67 -1 
+          128 67 127 -1 
+          127 67 126 -1 
+          104 105 88 -1 
+          88 105 106 -1 
+          88 106 87 -1 
+          87 106 107 -1 
+          87 107 86 -1 
+          86 107 108 -1 
+          86 108 85 -1 
+          85 108 109 -1 
+          85 109 84 -1 
+          84 109 110 -1 
+          84 110 83 -1 
+          83 110 111 -1 
+          83 111 82 -1 
+          82 111 112 -1 
+          82 112 113 -1 
+          98 99 93 -1 
+          93 99 100 -1 
+          93 100 92 -1 
+          92 100 101 -1 
+          92 101 91 -1 
+          91 101 102 -1 
+          91 102 90 -1 
+          90 102 103 -1 
+          90 103 89 -1 
+          89 103 104 -1 
+          89 104 88 -1 
+          94 95 97 -1 
+          94 97 98 -1 
+          94 98 93 -1 
+          81 82 78 -1 
+          81 78 79 -1 
+          81 79 80 -1 
+          78 82 113 -1 
+          78 113 114 -1 
+          78 114 115 -1 
+          78 115 77 -1 
+          120 73 119 -1 
+          119 73 74 -1 
+          119 74 118 -1 
+          118 74 75 -1 
+          118 75 117 -1 
+          117 75 76 -1 
+          117 76 116 -1 
+          116 76 77 -1 
+          116 77 115 -1 
+          126 68 125 -1 
+          125 68 69 -1 
+          125 69 124 -1 
+          124 69 70 -1 
+          124 70 123 -1 
+          123 70 71 -1 
+          123 71 122 -1 
+          122 71 72 -1 
+          122 72 121 -1 
+          121 72 73 -1 
+          121 73 120 -1 
+          126 67 68 -1 
+          0 64 65 -1 
+          0 65 96 -1 
+          64 63 66 -1 
+          64 66 65 -1 
+          63 62 67 -1 
+          63 67 66 -1 
+          62 61 68 -1 
+          62 68 67 -1 
+          61 60 69 -1 
+          61 69 68 -1 
+          60 59 70 -1 
+          60 70 69 -1 
+          59 58 71 -1 
+          59 71 70 -1 
+          58 57 72 -1 
+          58 72 71 -1 
+          57 56 73 -1 
+          57 73 72 -1 
+          56 55 74 -1 
+          56 74 73 -1 
+          55 54 75 -1 
+          55 75 74 -1 
+          54 53 76 -1 
+          54 76 75 -1 
+          53 52 77 -1 
+          53 77 76 -1 
+          52 51 78 -1 
+          52 78 77 -1 
+          51 50 79 -1 
+          51 79 78 -1 
+          50 49 80 -1 
+          50 80 79 -1 
+          49 48 81 -1 
+          49 81 80 -1 
+          48 47 82 -1 
+          48 82 81 -1 
+          47 46 83 -1 
+          47 83 82 -1 
+          46 45 84 -1 
+          46 84 83 -1 
+          45 44 85 -1 
+          45 85 84 -1 
+          44 43 86 -1 
+          44 86 85 -1 
+          43 42 87 -1 
+          43 87 86 -1 
+          42 41 88 -1 
+          42 88 87 -1 
+          41 40 89 -1 
+          41 89 88 -1 
+          40 39 90 -1 
+          40 90 89 -1 
+          39 38 91 -1 
+          39 91 90 -1 
+          38 37 92 -1 
+          38 92 91 -1 
+          37 36 93 -1 
+          37 93 92 -1 
+          36 35 94 -1 
+          36 94 93 -1 
+          35 1 95 -1 
+          35 95 94 -1 
+          1 0 96 -1 
+          1 96 95 -1 
+        ]
+        coord DEF Cylinder2_Coord Coordinate {
+         point [
+          0 1 -6
+          -1.17054 1 -5.88471
+          -1.07212 1 -5.3899
+          -1.05189 1 -5.39596
+          .02145 1 -5.49809
+          1.09408 1 -5.38886
+          2.1248 1 -5.07248
+          3.07398 1 -4.56108
+          3.90517 1 -3.87434
+          4.5864 1 -3.03864
+          5.0915 1 -2.08609
+          5.40107 1 -1.0533
+          5.5032 1 .02003
+          5.39398 1 1.09267
+          5.07759 1 2.12338
+          4.5662 1 3.07257
+          3.87945 1 3.90375
+          3.04375 1 4.58498
+          2.0912 1 5.09009
+          1.05842 1 5.39966
+          -.01492 1 5.50179
+          -1.08755 1 5.39256
+          -2.11827 1 5.07617
+          -3.06746 1 4.56478
+          -3.89864 1 3.87804
+          -4.57987 1 3.04233
+          -5.08498 1 2.08979
+          -5.39454 1 1.057
+          -5.49668 1 -.01633
+          -5.38745 1 -1.08897
+          -5.07106 1 -2.11968
+          -4.55967 1 -3.06887
+          -3.87292 1 -3.90005
+          -3.03722 1 -4.58129
+          -2.08467 1 -5.08639
+          -2.2961 1 -5.54328
+          -3.33342 1 -4.98882
+          -4.24264 1 -4.24264
+          -4.98882 1 -3.33342
+          -5.54328 1 -2.2961
+          -5.88471 1 -1.17054
+          -6 1 -0
+          -5.88471 1 1.17054
+          -5.54328 1 2.2961
+          -4.98882 1 3.33342
+          -4.24264 1 4.24264
+          -3.33342 1 4.98882
+          -2.2961 1 5.54328
+          -1.17054 1 5.88471
+          -0 1 6
+          1.17054 1 5.88471
+          2.2961 1 5.54328
+          3.33342 1 4.98882
+          4.24264 1 4.24264
+          4.98882 1 3.33342
+          5.54328 1 2.2961
+          5.88471 1 1.17054
+          6 1 0
+          5.88471 1 -1.17054
+          5.54328 1 -2.2961
+          4.98882 1 -3.33342
+          4.24264 1 -4.24264
+          3.33342 1 -4.98882
+          2.2961 1 -5.54328
+          1.17054 1 -5.88471
+          1.17054 -1 -5.88471
+          2.2961 -1 -5.54328
+          3.33342 -1 -4.98882
+          4.24264 -1 -4.24264
+          4.98882 -1 -3.33342
+          5.54328 -1 -2.2961
+          5.88471 -1 -1.17054
+          6 -1 -0
+          5.88471 -1 1.17054
+          5.54328 -1 2.2961
+          4.98882 -1 3.33342
+          4.24264 -1 4.24264
+          3.33342 -1 4.98882
+          2.2961 -1 5.54328
+          1.17054 -1 5.88471
+          -0 -1 6
+          -1.17054 -1 5.88471
+          -2.2961 -1 5.54328
+          -3.33342 -1 4.98882
+          -4.24264 -1 4.24264
+          -4.98882 -1 3.33342
+          -5.54328 -1 2.2961
+          -5.88471 -1 1.17054
+          -6 -1 -0
+          -5.88471 -1 -1.17054
+          -5.54328 -1 -2.2961
+          -4.98882 -1 -3.33342
+          -4.24264 -1 -4.24264
+          -3.33342 -1 -4.98882
+          -2.2961 -1 -5.54328
+          -1.17054 -1 -5.88471
+          0 -1 -6
+          0 -1 -5.50037
+          -1.05842 -1 -5.39966
+          -2.0912 -1 -5.09009
+          -3.04375 -1 -4.58498
+          -3.87945 -1 -3.90375
+          -4.5662 -1 -3.07257
+          -5.07759 -1 -2.12338
+          -5.39398 -1 -1.09267
+          -5.5032 -1 -.02003
+          -5.40107 -1 1.0533
+          -5.0915 -1 2.08609
+          -4.5864 -1 3.03864
+          -3.90517 -1 3.87434
+          -3.07398 -1 4.56108
+          -2.1248 -1 5.07248
+          -1.09408 -1 5.38886
+          -.02145 -1 5.49809
+          1.05189 -1 5.39596
+          2.08467 -1 5.08639
+          3.03722 -1 4.58129
+          3.87292 -1 3.90005
+          4.55967 -1 3.06887
+          5.07106 -1 2.11968
+          5.38745 -1 1.08897
+          5.49668 -1 .01633
+          5.39454 -1 -1.057
+          5.08498 -1 -2.08979
+          4.57987 -1 -3.04233
+          3.89864 -1 -3.87804
+          3.06746 -1 -4.56478
+          2.11827 -1 -5.07617
+          1.08755 -1 -5.39256
+          .01492 -1 -5.50179
+         ]
+        }
+       }
+      }
+     ]
+    }
+    DEF dad_Cylinder3 Transform {
+     rotation 0 0 1 1.571
+     scale 1.1 1.5 1.1
+     children [
+      DEF Cylinder3 Shape {
+       appearance Appearance {
+        material USE Green
+       }
+       geometry DEF Cylinder3_Geo IndexedFaceSet {
+        creaseAngle 0.524
+        coordIndex [
+          0 1 2 -1 
+          0 2 3 -1 
+          4 5 1 -1 
+          4 1 0 -1 
+          6 7 5 -1 
+          6 5 4 -1 
+          8 9 7 -1 
+          8 7 6 -1 
+          10 11 9 -1 
+          10 9 8 -1 
+          12 13 11 -1 
+          12 11 10 -1 
+          14 15 13 -1 
+          14 13 12 -1 
+          16 17 15 -1 
+          16 15 14 -1 
+          18 19 17 -1 
+          18 17 16 -1 
+          20 21 19 -1 
+          20 19 18 -1 
+          22 23 21 -1 
+          22 21 20 -1 
+          24 25 23 -1 
+          24 23 22 -1 
+          26 27 25 -1 
+          26 25 24 -1 
+          28 29 27 -1 
+          28 27 26 -1 
+          30 31 29 -1 
+          30 29 28 -1 
+          32 33 31 -1 
+          32 31 30 -1 
+          34 35 33 -1 
+          34 33 32 -1 
+          36 37 35 -1 
+          36 35 34 -1 
+          38 39 37 -1 
+          38 37 36 -1 
+          40 41 39 -1 
+          40 39 38 -1 
+          42 43 41 -1 
+          42 41 40 -1 
+          44 45 43 -1 
+          44 43 42 -1 
+          46 47 45 -1 
+          46 45 44 -1 
+          48 49 47 -1 
+          48 47 46 -1 
+          50 51 49 -1 
+          50 49 48 -1 
+          52 53 51 -1 
+          52 51 50 -1 
+          54 55 53 -1 
+          54 53 52 -1 
+          56 57 55 -1 
+          56 55 54 -1 
+          58 59 57 -1 
+          58 57 56 -1 
+          60 61 59 -1 
+          60 59 58 -1 
+          62 63 61 -1 
+          62 61 60 -1 
+          3 2 63 -1 
+          3 63 62 -1 
+        ]
+        coord DEF Cylinder3_Coord Coordinate {
+         point [
+          1.073 -1.00635 -5.39432
+          1.073 .99367 -5.39432
+          0 .98997 -5.5
+          0 -1.01006 -5.5
+          2.10476 -1.0024 -5.08134
+          2.10476 .99763 -5.08134
+          3.05564 -.99836 -4.57308
+          3.05564 1.00167 -4.57308
+          3.88909 -.99438 -3.88909
+          3.88909 1.00565 -3.88909
+          4.57308 -.99061 -3.05564
+          4.57308 1.00941 -3.05564
+          5.08134 -.98721 -2.10476
+          5.08134 1.01282 -2.10476
+          5.39432 -.9843 -1.073
+          5.39432 1.01573 -1.073
+          5.5 -.98199 -0
+          5.5 1.01803 -0
+          5.39432 -.98038 1.073
+          5.39432 1.01965 1.073
+          5.08134 -.97952 2.10476
+          5.08134 1.02051 2.10476
+          4.57308 -.97945 3.05564
+          4.57308 1.02058 3.05564
+          3.88909 -.98017 3.88909
+          3.88909 1.01986 3.88909
+          3.05564 -.98165 4.57308
+          3.05564 1.01838 4.57308
+          2.10476 -.98383 5.08134
+          2.10476 1.01619 5.08134
+          1.073 -.98664 5.39432
+          1.073 1.01338 5.39432
+          -0 -.98997 5.5
+          -0 1.01006 5.5
+          -1.073 -.99367 5.39432
+          -1.073 1.00635 5.39432
+          -2.10476 -.99763 5.08134
+          -2.10476 1.0024 5.08134
+          -3.05564 -1.00167 4.57308
+          -3.05564 .99836 4.57308
+          -3.88909 -1.00565 3.88909
+          -3.88909 .99438 3.88909
+          -4.57308 -1.00941 3.05564
+          -4.57308 .99061 3.05564
+          -5.08134 -1.01282 2.10476
+          -5.08134 .98721 2.10476
+          -5.39432 -1.01573 1.073
+          -5.39432 .9843 1.073
+          -5.5 -1.01803 -0
+          -5.5 .98199 -0
+          -5.39432 -1.01965 -1.073
+          -5.39432 .98038 -1.073
+          -5.08134 -1.02051 -2.10476
+          -5.08134 .97952 -2.10476
+          -4.57308 -1.02058 -3.05564
+          -4.57308 .97945 -3.05564
+          -3.88909 -1.01986 -3.88909
+          -3.88909 .98017 -3.88909
+          -3.05564 -1.01838 -4.57308
+          -3.05564 .98165 -4.57308
+          -2.10476 -1.01619 -5.08134
+          -2.10476 .98383 -5.08134
+          -1.073 -1.01338 -5.39432
+          -1.073 .98664 -5.39432
+         ]
+        }
+       }
+      }
+     ]
+    }
+    DEF dad_Cylinder5 Transform {
+     translation 0 0 -8.4
+     rotation 1 0 0 1.571
+     children [
+      DEF Cylinder5 Shape {
+       appearance Appearance {
+        material USE Green
+       }
+       geometry DEF GeoCylinder5 Cylinder {
+        height 4.250
+        radius 2.000
+       }
+      }
+     ]
+    }
+    DEF dad_Box10 Transform {
+     translation 0 2 -8.4
+     children [
+      DEF Box10 Shape {
+       appearance Appearance {
+        material USE Green
+       }
+       geometry DEF GeoBox10 Box {
+        size .25 1 4.25
+       }
+      }
+     ]
+    }
+   ]
+  }
+  DEF dad_lab_posttop Transform {
+   translation 0 0 -11
+   rotation -1 0 0 1.571
+   children [
+    DEF alpha_posttop Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoCylinder6 Cylinder {
+      height 1.000
+      radius 2.000
+     }
+    }
+   ]
+  }
+  DEF dad_alpha_arm Transform {
+   translation 0 -20.5 -5
+   children [
+    DEF alpha_arm Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox7 Box {
+      size 4 1 13
+     }
+    }
+   ]
+  }
+  DEF dad_gamma_arm1 Transform {
+   translation -6 -20.5 0
+   children [
+    DEF gamma_arm1 Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox18 Box {
+      size 1 2 .25
+     }
+    }
+   ]
+  }
+  DEF dad_Box12 Transform {
+   translation 0 2 -11
+   children [
+    DEF Box12 Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox12 Box {
+      size .25 1 1
+     }
+    }
+   ]
+  }
+  DEF dad_delta_frame Transform {
+   rotation 0 0 1 -.349
+   children [
+    DEF dad_delta_mount Transform {
+     translation 0 0 -14.25
+     rotation -1 0 0 1.571
+     children [
+      DEF delta_mount Shape {
+       appearance Appearance {
+        material DEF Yellow Material {
+         ambientIntensity 0.200
+         shininess 0.200
+         diffuseColor .83529 .83529 0
+        }
+       }
+       geometry DEF GeoCylinder2 Cylinder {
+        height 5.500
+        radius 2.000
+       }
+      }
+     ]
+    }
+    DEF dad_delta_arm Transform {
+     translation -10 0 -15
+     children [
+      DEF delta_arm Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoBox8 Box {
+        size 20 3 1
+       }
+      }
+     ]
+    }
+    DEF dad_delta_arm0 Transform {
+     translation -20 0 -6.5
+     children [
+      DEF delta_arm0 Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoBox6 Box {
+        size 1 3 18
+       }
+      }
+     ]
+    }
+    DEF dad_Cylinder14 Transform {
+     translation -18 0 0
+     rotation 0 0 -1 1.571
+     children [
+      DEF Cylinder14 Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoCylinder14 Cylinder {
+        height 3.000
+        radius 1.000
+       }
+      }
+     ]
+    }
+    DEF dad_detector_beam Transform {
+     translation -10 0 0
+     rotation 0 0 1 1.571
+     children [
+      DEF detector_beam Shape {
+       appearance Appearance {
+        material USE White
+       }
+       geometry DEF GeoCylinder21 Cylinder {
+        height 20.000
+        radius 0.050
+       }
+      }
+     ]
+    }
+    DEF dad_Box13 Transform {
+     translation 0 2 -14.25
+     children [
+      DEF Box13 Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoBox13 Box {
+        size .25 1 5.5
+       }
+      }
+     ]
+    }
+   ]
+  }
+ ]
+}
+DEF VP Viewpoint {
+ description "VP"
+ jump TRUE
+ fieldOfView 1.165
+ position 40 40 40
+ orientation -.754 .657 -0 1.001
+}
+DEF dad_gamma_arm2 Transform {
+ translation -9 -22.5 0
+ children [
+  DEF gamma_arm2 Shape {
+   appearance Appearance {
+    material DEF Black Material {
+     ambientIntensity 0.200
+     shininess 0.200
+     diffuseColor .20784 .20784 .20784
+    }
+   }
+   geometry DEF GeoBox19 Box {
+    size 1 2 .25
+   }
+  }
+ ]
+}
+DEF dad_gamma_base0 Transform {
+ translation 0 -22.5 0
+ rotation 0 1 0 .349
+ children [
+  DEF gamma_base0 Shape {
+   appearance Appearance {
+    material USE Black
+   }
+   geometry DEF GeoCylinder9 Cylinder {
+    height 2.000
+    radius 9.000
+   }
+  }
+ ]
+}
+DEF dad_floor Transform {
+ translation 0 -23.5 0
+ children [
+  DEF floor Shape {
+   appearance Appearance {
+    material USE Black
+   }
+   geometry DEF GeoBox16 Box {
+    size 60 .2 40
+   }
+  }
+ ]
+}
diff --git a/script/test/diffcalc (copy)/model/sixc.fxw b/script/test/diffcalc (copy)/model/sixc.fxw
new file mode 100644
index 0000000..51d97a4
Binary files /dev/null and b/script/test/diffcalc (copy)/model/sixc.fxw differ
diff --git a/script/test/diffcalc (copy)/model/sixc.wcfg b/script/test/diffcalc (copy)/model/sixc.wcfg
new file mode 100644
index 0000000..2fa6961
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/sixc.wcfg	
@@ -0,0 +1,6 @@
+dad_alpha_frame	rotation	pv["DIFFSIM:SIXC:ALPHA.RBV"]
+dad_delta_frame	rotation	pv["DIFFSIM:SIXC:DELTA.RBV"]
+dad_gamma_frame	rotation	pv["DIFFSIM:SIXC:GAMMA.RBV"]
+dad_omega_frame	rotation	pv["DIFFSIM:SIXC:OMEGA.RBV"]
+dad_chi_frame	rotation	pv["DIFFSIM:SIXC:CHI.RBV"]
+dad_phi_frame	rotation	pv["DIFFSIM:SIXC:PHI.RBV"]
diff --git a/script/test/diffcalc (copy)/model/sixc.wrl b/script/test/diffcalc (copy)/model/sixc.wrl
new file mode 100644
index 0000000..32ad769
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/sixc.wrl	
@@ -0,0 +1,1101 @@
+#VRML V2.0 utf8
+WorldInfo {
+ title "fourc"
+ info ["This Web3D Content was created with Flux Studio, a Web3D authoring tool"
+ "www.mediamachines.com"
+ "This Web3D Content was created with Flux Studio, a Web3D authoring tool"]
+}
+## Vizthumbnail  Thumb_fourc_wrl36454531255104963.jpg
+DirectionalLight {
+ intensity 1.000
+ ambientIntensity 0.500
+ direction -.621 -.23944 -.74634
+ color 1 1 1
+ on TRUE
+}
+DirectionalLight {
+ intensity 1.000
+ ambientIntensity 0.000
+ direction -.01373 -.46642 -.88446
+ color 1 1 1
+ on TRUE
+}
+DEF lab_x Shape {
+ appearance Appearance {
+  material DEF Rust Material {
+   ambientIntensity 0.200
+   shininess 0.200
+   diffuseColor .50196 .50196 .50196
+  }
+ }
+ geometry DEF GeoCylinder15 Cylinder {
+  height 60.000
+  radius 0.020
+ }
+}
+DEF dad_lab_z Transform {
+ rotation 1 0 0 1.571
+ children [
+  DEF lab_z Shape {
+   appearance Appearance {
+    material USE Rust
+   }
+   geometry DEF GeoCylinder17 Cylinder {
+    height 40.000
+    radius 0.020
+   }
+  }
+ ]
+}
+DEF dad_lab_beam Transform {
+ translation 10 0 0
+ rotation 0 0 1 1.571
+ children [
+  DEF lab_beam Shape {
+   appearance Appearance {
+    material DEF White Material {
+     ambientIntensity 0.500
+     shininess 0.100
+     transparency 0.500
+     diffuseColor 1 1 1
+     emissiveColor 1 1 1
+    }
+   }
+   geometry DEF GeoCylinder20 Cylinder {
+    height 20.000
+    radius 0.050
+   }
+  }
+ ]
+}
+DEF dad_lab_beam0 Transform {
+ translation 20 0 0
+ rotation 0 0 1 1.571
+ children [
+  DEF lab_beam0 Shape {
+   appearance Appearance {
+    material DEF Shiny_Black Material {
+     ambientIntensity 0.200
+     shininess 0.100
+     diffuseColor 1 1 1
+    }
+   }
+   geometry DEF GeoCylinder22 Cylinder {
+    height 4.000
+    radius 0.200
+   }
+  }
+ ]
+}
+DEF dad_Cone2 Transform {
+ translation 17.5 0 0
+ rotation 0 0 1 1.571
+ children [
+  DEF Cone2 Shape {
+   appearance Appearance {
+    material USE Shiny_Black
+   }
+   geometry DEF GeoCone2 Cone {
+    height 1.500
+    bottomRadius 0.500
+   }
+  }
+ ]
+}
+DEF dad_lab_y Transform {
+ rotation 0 0 -1 1.571
+ children [
+  DEF lab_y Shape {
+   appearance Appearance {
+    material USE Rust
+   }
+   geometry DEF GeoCylinder16 Cylinder {
+    height 60.000
+    radius 0.020
+   }
+  }
+ ]
+}
+DEF dad_alpha_frame Transform {
+ rotation 0 1 0 .175
+ children [
+  DEF dad_alpha_base Transform {
+   translation 0 -20.5 0
+   children [
+    DEF alpha_base Shape {
+     appearance Appearance {
+      material DEF Red Material {
+       ambientIntensity 0.200
+       shininess 0.200
+       diffuseColor .50196 0 0
+      }
+     }
+     geometry DEF GeoCylinder1 Cylinder {
+      height 2.000
+      radius 6.000
+     }
+    }
+   ]
+  }
+  DEF dad_lab_post Transform {
+   translation 0 -10 -11
+   children [
+    DEF alpha_post Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox1 Box {
+      size 4 20 1
+     }
+    }
+   ]
+  }
+  DEF dad_omega_frame Transform {
+   rotation 0 0 1 -.175
+   children [
+    DEF dad_chi_frame Transform {
+     rotation 1 0 0 -.785
+     children [
+      DEF dad_phi_frame Transform {
+       rotation 0 0 1 -.349
+       children [
+        DEF dad_Cylinder7 Transform {
+         translation 0 0 -4
+         rotation 1 0 0 1.571
+         children [
+          DEF Cylinder7 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoCylinder7 Cylinder {
+            height 2.000
+            radius 1.000
+           }
+          }
+         ]
+        }
+        DEF dad_Cylinder8 Transform {
+         translation 0 0 -3.5
+         rotation 1 0 0 1.571
+         children [
+          DEF Cylinder8 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoCylinder8 Cylinder {
+            height 6.000
+            radius 0.250
+           }
+          }
+         ]
+        }
+        DEF Box3 Shape {
+         appearance Appearance {
+          material USE White
+         }
+         geometry DEF GeoBox3 Box {
+          size 1 1 1
+         }
+        }
+        DEF dad_Box11 Transform {
+         translation 0 1 -4
+         children [
+          DEF Box11 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoBox11 Box {
+            size .25 .5 2
+           }
+          }
+         ]
+        }
+        DEF Box4 Shape {
+         appearance Appearance {
+          material DEF White_wire Material {
+           emissiveColor 1 1 1
+          }
+         }
+         geometry IndexedLineSet {
+          coordIndex [
+            0 1 2 0 
+            -1 0 2 3 
+            0 -1 1 5 
+            6 1 -1 1 
+            6 2 1 -1 
+            2 6 7 2 
+            -1 2 7 3 
+            2 -1 3 7 
+            4 3 -1 3 
+            4 0 3 -1 
+            0 4 5 0 
+            -1 0 5 1 
+            0 -1 6 5 
+            4 6 -1 6 
+            4 7 6 -1 
+          ]
+          coord Coordinate {
+           point [
+            -.5 .5 -.5
+            -.5 .5 .5
+            .5 .5 .5
+            .5 .5 -.5
+            -.5 -.5 -.5
+            -.5 -.5 .5
+            .5 -.5 .5
+            .5 -.5 -.5
+           ]
+          }
+         }
+        }
+       ]
+      }
+      DEF dad_Box2 Transform {
+       translation 0 0 -5.5
+       children [
+        DEF Box2 Shape {
+         appearance Appearance {
+          material DEF Purple Material {
+           ambientIntensity 0.200
+           shininess 0.200
+           diffuseColor .9176 0 .874
+          }
+         }
+         geometry DEF GeoBox2 Box {
+          size 2.8 2.8 1.5
+         }
+        }
+       ]
+      }
+      DEF dad_Box6 Transform {
+       translation 0 1.25 -5.5
+       children [
+        DEF Box6 Shape {
+         appearance Appearance {
+          material USE Purple
+         }
+         geometry DEF GeoBox21 Box {
+          size .25 1 1.5
+         }
+        }
+       ]
+      }
+     ]
+    }
+    DEF dad_Cylinder2 Transform {
+     rotation 0 0 1 1.571
+     scale 1.1 1.5 1.1
+     children [
+      DEF Cylinder2 Shape {
+       appearance Appearance {
+        material DEF Green Material {
+         ambientIntensity 0.200
+         shininess 0.200
+         diffuseColor .00784 .65098 .02353
+        }
+       }
+       geometry DEF Cylinder2_Geo IndexedFaceSet {
+        creaseAngle 0.524
+        coordIndex [
+          49 50 48 -1 
+          48 50 51 -1 
+          48 51 47 -1 
+          47 51 20 -1 
+          47 20 21 -1 
+          12 13 56 -1 
+          56 13 14 -1 
+          56 14 55 -1 
+          55 14 15 -1 
+          55 15 54 -1 
+          54 15 16 -1 
+          54 16 53 -1 
+          53 16 17 -1 
+          53 17 52 -1 
+          52 17 18 -1 
+          52 18 51 -1 
+          51 18 19 -1 
+          51 19 20 -1 
+          5 6 62 -1 
+          62 6 7 -1 
+          62 7 61 -1 
+          61 7 8 -1 
+          61 8 60 -1 
+          60 8 9 -1 
+          60 9 59 -1 
+          59 9 10 -1 
+          59 10 58 -1 
+          58 10 11 -1 
+          58 11 57 -1 
+          57 11 12 -1 
+          57 12 56 -1 
+          5 63 4 -1 
+          4 63 64 -1 
+          4 64 3 -1 
+          3 64 1 -1 
+          3 1 2 -1 
+          2 1 35 -1 
+          2 35 36 -1 
+          28 41 27 -1 
+          27 41 42 -1 
+          27 42 26 -1 
+          26 42 43 -1 
+          26 43 25 -1 
+          25 43 44 -1 
+          25 44 24 -1 
+          24 44 45 -1 
+          24 45 23 -1 
+          23 45 46 -1 
+          23 46 22 -1 
+          22 46 47 -1 
+          22 47 21 -1 
+          34 36 33 -1 
+          33 36 37 -1 
+          33 37 32 -1 
+          32 37 38 -1 
+          32 38 31 -1 
+          31 38 39 -1 
+          31 39 30 -1 
+          30 39 40 -1 
+          30 40 29 -1 
+          29 40 41 -1 
+          29 41 28 -1 
+          1 64 0 -1 
+          2 36 34 -1 
+          63 5 62 -1 
+          95 96 97 -1 
+          97 96 65 -1 
+          97 65 129 -1 
+          129 65 66 -1 
+          129 66 128 -1 
+          128 66 67 -1 
+          128 67 127 -1 
+          127 67 126 -1 
+          104 105 88 -1 
+          88 105 106 -1 
+          88 106 87 -1 
+          87 106 107 -1 
+          87 107 86 -1 
+          86 107 108 -1 
+          86 108 85 -1 
+          85 108 109 -1 
+          85 109 84 -1 
+          84 109 110 -1 
+          84 110 83 -1 
+          83 110 111 -1 
+          83 111 82 -1 
+          82 111 112 -1 
+          82 112 113 -1 
+          98 99 93 -1 
+          93 99 100 -1 
+          93 100 92 -1 
+          92 100 101 -1 
+          92 101 91 -1 
+          91 101 102 -1 
+          91 102 90 -1 
+          90 102 103 -1 
+          90 103 89 -1 
+          89 103 104 -1 
+          89 104 88 -1 
+          94 95 97 -1 
+          94 97 98 -1 
+          94 98 93 -1 
+          81 82 78 -1 
+          81 78 79 -1 
+          81 79 80 -1 
+          78 82 113 -1 
+          78 113 114 -1 
+          78 114 115 -1 
+          78 115 77 -1 
+          120 73 119 -1 
+          119 73 74 -1 
+          119 74 118 -1 
+          118 74 75 -1 
+          118 75 117 -1 
+          117 75 76 -1 
+          117 76 116 -1 
+          116 76 77 -1 
+          116 77 115 -1 
+          126 68 125 -1 
+          125 68 69 -1 
+          125 69 124 -1 
+          124 69 70 -1 
+          124 70 123 -1 
+          123 70 71 -1 
+          123 71 122 -1 
+          122 71 72 -1 
+          122 72 121 -1 
+          121 72 73 -1 
+          121 73 120 -1 
+          126 67 68 -1 
+          0 64 65 -1 
+          0 65 96 -1 
+          64 63 66 -1 
+          64 66 65 -1 
+          63 62 67 -1 
+          63 67 66 -1 
+          62 61 68 -1 
+          62 68 67 -1 
+          61 60 69 -1 
+          61 69 68 -1 
+          60 59 70 -1 
+          60 70 69 -1 
+          59 58 71 -1 
+          59 71 70 -1 
+          58 57 72 -1 
+          58 72 71 -1 
+          57 56 73 -1 
+          57 73 72 -1 
+          56 55 74 -1 
+          56 74 73 -1 
+          55 54 75 -1 
+          55 75 74 -1 
+          54 53 76 -1 
+          54 76 75 -1 
+          53 52 77 -1 
+          53 77 76 -1 
+          52 51 78 -1 
+          52 78 77 -1 
+          51 50 79 -1 
+          51 79 78 -1 
+          50 49 80 -1 
+          50 80 79 -1 
+          49 48 81 -1 
+          49 81 80 -1 
+          48 47 82 -1 
+          48 82 81 -1 
+          47 46 83 -1 
+          47 83 82 -1 
+          46 45 84 -1 
+          46 84 83 -1 
+          45 44 85 -1 
+          45 85 84 -1 
+          44 43 86 -1 
+          44 86 85 -1 
+          43 42 87 -1 
+          43 87 86 -1 
+          42 41 88 -1 
+          42 88 87 -1 
+          41 40 89 -1 
+          41 89 88 -1 
+          40 39 90 -1 
+          40 90 89 -1 
+          39 38 91 -1 
+          39 91 90 -1 
+          38 37 92 -1 
+          38 92 91 -1 
+          37 36 93 -1 
+          37 93 92 -1 
+          36 35 94 -1 
+          36 94 93 -1 
+          35 1 95 -1 
+          35 95 94 -1 
+          1 0 96 -1 
+          1 96 95 -1 
+        ]
+        coord DEF Cylinder2_Coord Coordinate {
+         point [
+          0 1 -6
+          -1.17054 1 -5.88471
+          -1.07212 1 -5.3899
+          -1.05189 1 -5.39596
+          .02145 1 -5.49809
+          1.09408 1 -5.38886
+          2.1248 1 -5.07248
+          3.07398 1 -4.56108
+          3.90517 1 -3.87434
+          4.5864 1 -3.03864
+          5.0915 1 -2.08609
+          5.40107 1 -1.0533
+          5.5032 1 .02003
+          5.39398 1 1.09267
+          5.07759 1 2.12338
+          4.5662 1 3.07257
+          3.87945 1 3.90375
+          3.04375 1 4.58498
+          2.0912 1 5.09009
+          1.05842 1 5.39966
+          -.01492 1 5.50179
+          -1.08755 1 5.39256
+          -2.11827 1 5.07617
+          -3.06746 1 4.56478
+          -3.89864 1 3.87804
+          -4.57987 1 3.04233
+          -5.08498 1 2.08979
+          -5.39454 1 1.057
+          -5.49668 1 -.01633
+          -5.38745 1 -1.08897
+          -5.07106 1 -2.11968
+          -4.55967 1 -3.06887
+          -3.87292 1 -3.90005
+          -3.03722 1 -4.58129
+          -2.08467 1 -5.08639
+          -2.2961 1 -5.54328
+          -3.33342 1 -4.98882
+          -4.24264 1 -4.24264
+          -4.98882 1 -3.33342
+          -5.54328 1 -2.2961
+          -5.88471 1 -1.17054
+          -6 1 -0
+          -5.88471 1 1.17054
+          -5.54328 1 2.2961
+          -4.98882 1 3.33342
+          -4.24264 1 4.24264
+          -3.33342 1 4.98882
+          -2.2961 1 5.54328
+          -1.17054 1 5.88471
+          -0 1 6
+          1.17054 1 5.88471
+          2.2961 1 5.54328
+          3.33342 1 4.98882
+          4.24264 1 4.24264
+          4.98882 1 3.33342
+          5.54328 1 2.2961
+          5.88471 1 1.17054
+          6 1 0
+          5.88471 1 -1.17054
+          5.54328 1 -2.2961
+          4.98882 1 -3.33342
+          4.24264 1 -4.24264
+          3.33342 1 -4.98882
+          2.2961 1 -5.54328
+          1.17054 1 -5.88471
+          1.17054 -1 -5.88471
+          2.2961 -1 -5.54328
+          3.33342 -1 -4.98882
+          4.24264 -1 -4.24264
+          4.98882 -1 -3.33342
+          5.54328 -1 -2.2961
+          5.88471 -1 -1.17054
+          6 -1 -0
+          5.88471 -1 1.17054
+          5.54328 -1 2.2961
+          4.98882 -1 3.33342
+          4.24264 -1 4.24264
+          3.33342 -1 4.98882
+          2.2961 -1 5.54328
+          1.17054 -1 5.88471
+          -0 -1 6
+          -1.17054 -1 5.88471
+          -2.2961 -1 5.54328
+          -3.33342 -1 4.98882
+          -4.24264 -1 4.24264
+          -4.98882 -1 3.33342
+          -5.54328 -1 2.2961
+          -5.88471 -1 1.17054
+          -6 -1 -0
+          -5.88471 -1 -1.17054
+          -5.54328 -1 -2.2961
+          -4.98882 -1 -3.33342
+          -4.24264 -1 -4.24264
+          -3.33342 -1 -4.98882
+          -2.2961 -1 -5.54328
+          -1.17054 -1 -5.88471
+          0 -1 -6
+          0 -1 -5.50037
+          -1.05842 -1 -5.39966
+          -2.0912 -1 -5.09009
+          -3.04375 -1 -4.58498
+          -3.87945 -1 -3.90375
+          -4.5662 -1 -3.07257
+          -5.07759 -1 -2.12338
+          -5.39398 -1 -1.09267
+          -5.5032 -1 -.02003
+          -5.40107 -1 1.0533
+          -5.0915 -1 2.08609
+          -4.5864 -1 3.03864
+          -3.90517 -1 3.87434
+          -3.07398 -1 4.56108
+          -2.1248 -1 5.07248
+          -1.09408 -1 5.38886
+          -.02145 -1 5.49809
+          1.05189 -1 5.39596
+          2.08467 -1 5.08639
+          3.03722 -1 4.58129
+          3.87292 -1 3.90005
+          4.55967 -1 3.06887
+          5.07106 -1 2.11968
+          5.38745 -1 1.08897
+          5.49668 -1 .01633
+          5.39454 -1 -1.057
+          5.08498 -1 -2.08979
+          4.57987 -1 -3.04233
+          3.89864 -1 -3.87804
+          3.06746 -1 -4.56478
+          2.11827 -1 -5.07617
+          1.08755 -1 -5.39256
+          .01492 -1 -5.50179
+         ]
+        }
+       }
+      }
+     ]
+    }
+    DEF dad_Cylinder3 Transform {
+     rotation 0 0 1 1.571
+     scale 1.1 1.5 1.1
+     children [
+      DEF Cylinder3 Shape {
+       appearance Appearance {
+        material USE Green
+       }
+       geometry DEF Cylinder3_Geo IndexedFaceSet {
+        creaseAngle 0.524
+        coordIndex [
+          0 1 2 -1 
+          0 2 3 -1 
+          4 5 1 -1 
+          4 1 0 -1 
+          6 7 5 -1 
+          6 5 4 -1 
+          8 9 7 -1 
+          8 7 6 -1 
+          10 11 9 -1 
+          10 9 8 -1 
+          12 13 11 -1 
+          12 11 10 -1 
+          14 15 13 -1 
+          14 13 12 -1 
+          16 17 15 -1 
+          16 15 14 -1 
+          18 19 17 -1 
+          18 17 16 -1 
+          20 21 19 -1 
+          20 19 18 -1 
+          22 23 21 -1 
+          22 21 20 -1 
+          24 25 23 -1 
+          24 23 22 -1 
+          26 27 25 -1 
+          26 25 24 -1 
+          28 29 27 -1 
+          28 27 26 -1 
+          30 31 29 -1 
+          30 29 28 -1 
+          32 33 31 -1 
+          32 31 30 -1 
+          34 35 33 -1 
+          34 33 32 -1 
+          36 37 35 -1 
+          36 35 34 -1 
+          38 39 37 -1 
+          38 37 36 -1 
+          40 41 39 -1 
+          40 39 38 -1 
+          42 43 41 -1 
+          42 41 40 -1 
+          44 45 43 -1 
+          44 43 42 -1 
+          46 47 45 -1 
+          46 45 44 -1 
+          48 49 47 -1 
+          48 47 46 -1 
+          50 51 49 -1 
+          50 49 48 -1 
+          52 53 51 -1 
+          52 51 50 -1 
+          54 55 53 -1 
+          54 53 52 -1 
+          56 57 55 -1 
+          56 55 54 -1 
+          58 59 57 -1 
+          58 57 56 -1 
+          60 61 59 -1 
+          60 59 58 -1 
+          62 63 61 -1 
+          62 61 60 -1 
+          3 2 63 -1 
+          3 63 62 -1 
+        ]
+        coord DEF Cylinder3_Coord Coordinate {
+         point [
+          1.073 -1.00635 -5.39432
+          1.073 .99367 -5.39432
+          0 .98997 -5.5
+          0 -1.01006 -5.5
+          2.10476 -1.0024 -5.08134
+          2.10476 .99763 -5.08134
+          3.05564 -.99836 -4.57308
+          3.05564 1.00167 -4.57308
+          3.88909 -.99438 -3.88909
+          3.88909 1.00565 -3.88909
+          4.57308 -.99061 -3.05564
+          4.57308 1.00941 -3.05564
+          5.08134 -.98721 -2.10476
+          5.08134 1.01282 -2.10476
+          5.39432 -.9843 -1.073
+          5.39432 1.01573 -1.073
+          5.5 -.98199 -0
+          5.5 1.01803 -0
+          5.39432 -.98038 1.073
+          5.39432 1.01965 1.073
+          5.08134 -.97952 2.10476
+          5.08134 1.02051 2.10476
+          4.57308 -.97945 3.05564
+          4.57308 1.02058 3.05564
+          3.88909 -.98017 3.88909
+          3.88909 1.01986 3.88909
+          3.05564 -.98165 4.57308
+          3.05564 1.01838 4.57308
+          2.10476 -.98383 5.08134
+          2.10476 1.01619 5.08134
+          1.073 -.98664 5.39432
+          1.073 1.01338 5.39432
+          -0 -.98997 5.5
+          -0 1.01006 5.5
+          -1.073 -.99367 5.39432
+          -1.073 1.00635 5.39432
+          -2.10476 -.99763 5.08134
+          -2.10476 1.0024 5.08134
+          -3.05564 -1.00167 4.57308
+          -3.05564 .99836 4.57308
+          -3.88909 -1.00565 3.88909
+          -3.88909 .99438 3.88909
+          -4.57308 -1.00941 3.05564
+          -4.57308 .99061 3.05564
+          -5.08134 -1.01282 2.10476
+          -5.08134 .98721 2.10476
+          -5.39432 -1.01573 1.073
+          -5.39432 .9843 1.073
+          -5.5 -1.01803 -0
+          -5.5 .98199 -0
+          -5.39432 -1.01965 -1.073
+          -5.39432 .98038 -1.073
+          -5.08134 -1.02051 -2.10476
+          -5.08134 .97952 -2.10476
+          -4.57308 -1.02058 -3.05564
+          -4.57308 .97945 -3.05564
+          -3.88909 -1.01986 -3.88909
+          -3.88909 .98017 -3.88909
+          -3.05564 -1.01838 -4.57308
+          -3.05564 .98165 -4.57308
+          -2.10476 -1.01619 -5.08134
+          -2.10476 .98383 -5.08134
+          -1.073 -1.01338 -5.39432
+          -1.073 .98664 -5.39432
+         ]
+        }
+       }
+      }
+     ]
+    }
+    DEF dad_Cylinder5 Transform {
+     translation 0 0 -8.4
+     rotation 1 0 0 1.571
+     children [
+      DEF Cylinder5 Shape {
+       appearance Appearance {
+        material USE Green
+       }
+       geometry DEF GeoCylinder5 Cylinder {
+        height 4.250
+        radius 2.000
+       }
+      }
+     ]
+    }
+    DEF dad_Box10 Transform {
+     translation 0 2 -8.4
+     children [
+      DEF Box10 Shape {
+       appearance Appearance {
+        material USE Green
+       }
+       geometry DEF GeoBox10 Box {
+        size .25 1 4.25
+       }
+      }
+     ]
+    }
+   ]
+  }
+  DEF dad_lab_posttop Transform {
+   translation 0 0 -11
+   rotation -1 0 0 1.571
+   children [
+    DEF alpha_posttop Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoCylinder6 Cylinder {
+      height 1.000
+      radius 2.000
+     }
+    }
+   ]
+  }
+  DEF dad_alpha_arm Transform {
+   translation 0 -20.5 -5
+   children [
+    DEF alpha_arm Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox7 Box {
+      size 4 1 13
+     }
+    }
+   ]
+  }
+  DEF dad_gamma_arm1 Transform {
+   translation -6 -20.5 0
+   children [
+    DEF gamma_arm1 Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox18 Box {
+      size 1 2 .25
+     }
+    }
+   ]
+  }
+  DEF dad_Box12 Transform {
+   translation 0 2 -11
+   children [
+    DEF Box12 Shape {
+     appearance Appearance {
+      material USE Red
+     }
+     geometry DEF GeoBox12 Box {
+      size .25 1 1
+     }
+    }
+   ]
+  }
+ ]
+}
+DEF dad_gamma_frame Transform {
+ rotation 0 1 0 .349
+ children [
+  DEF dad_lab_posttop0 Transform {
+   translation 0 0 -12.5
+   rotation -1 0 0 1.571
+   children [
+    DEF gamma_posttop Shape {
+     appearance Appearance {
+      material DEF Blue Material {
+       ambientIntensity 0.200
+       shininess 0.200
+       diffuseColor 0 0 .62745
+      }
+     }
+     geometry DEF GeoCylinder4 Cylinder {
+      height 1.000
+      radius 2.000
+     }
+    }
+   ]
+  }
+  DEF dad_lab_post0 Transform {
+   translation 0 -11 -12.5
+   children [
+    DEF gamma_post Shape {
+     appearance Appearance {
+      material USE Blue
+     }
+     geometry DEF GeoBox5 Box {
+      size 4 22 1
+     }
+    }
+   ]
+  }
+  DEF dad_gamma_base Transform {
+   translation 0 -22.5 0
+   children [
+    DEF gamma_base Shape {
+     appearance Appearance {
+      material USE Blue
+     }
+     geometry DEF GeoCylinder3 Cylinder {
+      height 2.000
+      radius 8.000
+     }
+    }
+   ]
+  }
+  DEF dad_gamma_arm Transform {
+   translation 0 -22.5 -6.5
+   children [
+    DEF gamma_arm Shape {
+     appearance Appearance {
+      material USE Blue
+     }
+     geometry DEF GeoBox4 Box {
+      size 4 1 13
+     }
+    }
+   ]
+  }
+  DEF dad_delta_frame Transform {
+   rotation 0 0 1 -.524
+   children [
+    DEF dad_delta_mount Transform {
+     translation 0 0 -15
+     rotation -1 0 0 1.571
+     children [
+      DEF delta_mount Shape {
+       appearance Appearance {
+        material DEF Yellow Material {
+         ambientIntensity 0.200
+         shininess 0.200
+         diffuseColor .83529 .83529 0
+        }
+       }
+       geometry DEF GeoCylinder2 Cylinder {
+        height 4.000
+        radius 2.000
+       }
+      }
+     ]
+    }
+    DEF dad_delta_arm Transform {
+     translation -10 0 -15
+     children [
+      DEF delta_arm Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoBox8 Box {
+        size 20 3 1
+       }
+      }
+     ]
+    }
+    DEF dad_delta_arm0 Transform {
+     translation -20 0 -6.5
+     children [
+      DEF delta_arm0 Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoBox6 Box {
+        size 1 3 18
+       }
+      }
+     ]
+    }
+    DEF dad_Cylinder14 Transform {
+     translation -18 0 0
+     rotation .577 -.577 .577 2.094
+     children [
+      DEF Cylinder14 Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoCylinder14 Cylinder {
+        height 3.000
+        radius 1.000
+       }
+      }
+     ]
+    }
+    DEF dad_detector_beam Transform {
+     translation -10 0 0
+     rotation 0 0 1 1.571
+     children [
+      DEF detector_beam Shape {
+       appearance Appearance {
+        material USE White
+       }
+       geometry DEF GeoCylinder21 Cylinder {
+        height 20.000
+        radius 0.050
+       }
+      }
+     ]
+    }
+    DEF dad_Box13 Transform {
+     translation 0 2 -15
+     children [
+      DEF Box13 Shape {
+       appearance Appearance {
+        material USE Yellow
+       }
+       geometry DEF GeoBox13 Box {
+        size .25 1 4
+       }
+      }
+     ]
+    }
+   ]
+  }
+  DEF dad_gamma_arm0 Transform {
+   translation -8 -22.5 0
+   children [
+    DEF gamma_arm0 Shape {
+     appearance Appearance {
+      material USE Blue
+     }
+     geometry DEF GeoBox17 Box {
+      size 1 2 .25
+     }
+    }
+   ]
+  }
+  DEF dad_Box14 Transform {
+   translation 0 2 -12.5
+   children [
+    DEF Box14 Shape {
+     appearance Appearance {
+      material USE Blue
+     }
+     geometry DEF GeoBox14 Box {
+      size .25 1 1
+     }
+    }
+   ]
+  }
+ ]
+}
+DEF VP Viewpoint {
+ description "VP"
+ jump TRUE
+ fieldOfView 1.165
+ position 40 40 40
+ orientation -.754 .657 -0 1.001
+}
+DEF dad_gamma_arm2 Transform {
+ translation -9 -24.5 0
+ children [
+  DEF gamma_arm2 Shape {
+   appearance Appearance {
+    material DEF Black Material {
+     ambientIntensity 0.200
+     shininess 0.200
+     diffuseColor .20784 .20784 .20784
+    }
+   }
+   geometry DEF GeoBox19 Box {
+    size 1 2 .25
+   }
+  }
+ ]
+}
+DEF dad_gamma_base0 Transform {
+ translation 0 -24.5 0
+ rotation 0 1 0 .349
+ children [
+  DEF gamma_base0 Shape {
+   appearance Appearance {
+    material USE Black
+   }
+   geometry DEF GeoCylinder9 Cylinder {
+    height 2.000
+    radius 9.000
+   }
+  }
+ ]
+}
+DEF dad_floor Transform {
+ translation 0 -25.5 0
+ children [
+  DEF floor Shape {
+   appearance Appearance {
+    material USE Black
+   }
+   geometry DEF GeoBox16 Box {
+    size 60 .2 40
+   }
+  }
+ ]
+}
diff --git a/script/test/diffcalc (copy)/model/sixc_horizontal.fxw b/script/test/diffcalc (copy)/model/sixc_horizontal.fxw
new file mode 100644
index 0000000..9eea919
Binary files /dev/null and b/script/test/diffcalc (copy)/model/sixc_horizontal.fxw differ
diff --git a/script/test/diffcalc (copy)/model/sixc_horizontal.wrl b/script/test/diffcalc (copy)/model/sixc_horizontal.wrl
new file mode 100644
index 0000000..3ec9d25
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/sixc_horizontal.wrl	
@@ -0,0 +1,1106 @@
+#VRML V2.0 utf8
+WorldInfo {
+ title "fourc"
+ info ["This Web3D Content was created with Flux Studio, a Web3D authoring tool"
+ "www.mediamachines.com"
+ "This Web3D Content was created with Flux Studio, a Web3D authoring tool"]
+}
+## Vizthumbnail  Thumb_sixc_horizontal_wrl8844311285236111.jpg
+DEF dad_GROUND_ROTATED Transform {
+ rotation 1 0 0 1.571
+ children [
+  DirectionalLight {
+   intensity 1.000
+   ambientIntensity 0.500
+   direction -.621 -.23944 -.74634
+   color 1 1 1
+   on TRUE
+  }
+  DirectionalLight {
+   intensity 1.000
+   ambientIntensity 0.000
+   direction -.01373 -.46642 -.88446
+   color 1 1 1
+   on TRUE
+  }
+  DEF lab_x Shape {
+   appearance Appearance {
+    material DEF Rust Material {
+     ambientIntensity 0.200
+     shininess 0.200
+     diffuseColor .50196 .50196 .50196
+    }
+   }
+   geometry DEF GeoCylinder15 Cylinder {
+    height 60.000
+    radius 0.020
+   }
+  }
+  DEF dad_lab_z Transform {
+   rotation 1 0 0 1.571
+   children [
+    DEF lab_z Shape {
+     appearance Appearance {
+      material USE Rust
+     }
+     geometry DEF GeoCylinder17 Cylinder {
+      height 40.000
+      radius 0.020
+     }
+    }
+   ]
+  }
+  DEF dad_lab_beam Transform {
+   translation 10 0 0
+   rotation 0 0 1 1.571
+   children [
+    DEF lab_beam Shape {
+     appearance Appearance {
+      material DEF White Material {
+       ambientIntensity 0.500
+       shininess 0.100
+       transparency 0.500
+       diffuseColor 1 1 1
+       emissiveColor 1 1 1
+      }
+     }
+     geometry DEF GeoCylinder20 Cylinder {
+      height 20.000
+      radius 0.050
+     }
+    }
+   ]
+  }
+  DEF dad_lab_beam0 Transform {
+   translation 20 0 0
+   rotation 0 0 1 1.571
+   children [
+    DEF lab_beam0 Shape {
+     appearance Appearance {
+      material DEF Shiny_Black Material {
+       ambientIntensity 0.200
+       shininess 0.100
+       diffuseColor 1 1 1
+      }
+     }
+     geometry DEF GeoCylinder22 Cylinder {
+      height 4.000
+      radius 0.200
+     }
+    }
+   ]
+  }
+  DEF dad_Cone2 Transform {
+   translation 17.5 0 0
+   rotation 0 0 1 1.571
+   children [
+    DEF Cone2 Shape {
+     appearance Appearance {
+      material USE Shiny_Black
+     }
+     geometry DEF GeoCone2 Cone {
+      height 1.500
+      bottomRadius 0.500
+     }
+    }
+   ]
+  }
+  DEF dad_lab_y Transform {
+   rotation 0 0 -1 1.571
+   children [
+    DEF lab_y Shape {
+     appearance Appearance {
+      material USE Rust
+     }
+     geometry DEF GeoCylinder16 Cylinder {
+      height 60.000
+      radius 0.020
+     }
+    }
+   ]
+  }
+  DEF dad_alpha_frame Transform {
+   rotation 0 1 0 .175
+   children [
+    DEF dad_alpha_base Transform {
+     translation 0 -20.5 0
+     children [
+      DEF alpha_base Shape {
+       appearance Appearance {
+        material DEF Red Material {
+         ambientIntensity 0.200
+         shininess 0.200
+         diffuseColor .50196 0 0
+        }
+       }
+       geometry DEF GeoCylinder1 Cylinder {
+        height 2.000
+        radius 6.000
+       }
+      }
+     ]
+    }
+    DEF dad_lab_post Transform {
+     translation 0 -10 -11
+     children [
+      DEF alpha_post Shape {
+       appearance Appearance {
+        material USE Red
+       }
+       geometry DEF GeoBox1 Box {
+        size 4 20 1
+       }
+      }
+     ]
+    }
+    DEF dad_omega_frame Transform {
+     rotation 0 0 1 -.175
+     children [
+      DEF dad_chi_frame Transform {
+       rotation 1 0 0 -.785
+       children [
+        DEF dad_phi_frame Transform {
+         rotation 0 0 1 -.349
+         children [
+          DEF dad_Cylinder7 Transform {
+           translation 0 0 -4
+           rotation 1 0 0 1.571
+           children [
+            DEF Cylinder7 Shape {
+             appearance Appearance {
+              material USE White
+             }
+             geometry DEF GeoCylinder7 Cylinder {
+              height 2.000
+              radius 1.000
+             }
+            }
+           ]
+          }
+          DEF dad_Cylinder8 Transform {
+           translation 0 0 -3.5
+           rotation 1 0 0 1.571
+           children [
+            DEF Cylinder8 Shape {
+             appearance Appearance {
+              material USE White
+             }
+             geometry DEF GeoCylinder8 Cylinder {
+              height 6.000
+              radius 0.250
+             }
+            }
+           ]
+          }
+          DEF Box3 Shape {
+           appearance Appearance {
+            material USE White
+           }
+           geometry DEF GeoBox3 Box {
+            size 1 1 1
+           }
+          }
+          DEF dad_Box11 Transform {
+           translation 0 1 -4
+           children [
+            DEF Box11 Shape {
+             appearance Appearance {
+              material USE White
+             }
+             geometry DEF GeoBox11 Box {
+              size .25 .5 2
+             }
+            }
+           ]
+          }
+          DEF Box4 Shape {
+           appearance Appearance {
+            material DEF White_wire Material {
+             emissiveColor 1 1 1
+            }
+           }
+           geometry IndexedLineSet {
+            coordIndex [
+              0 1 2 0 
+              -1 0 2 3 
+              0 -1 1 5 
+              6 1 -1 1 
+              6 2 1 -1 
+              2 6 7 2 
+              -1 2 7 3 
+              2 -1 3 7 
+              4 3 -1 3 
+              4 0 3 -1 
+              0 4 5 0 
+              -1 0 5 1 
+              0 -1 6 5 
+              4 6 -1 6 
+              4 7 6 -1 
+            ]
+            coord Coordinate {
+             point [
+              -.5 .5 -.5
+              -.5 .5 .5
+              .5 .5 .5
+              .5 .5 -.5
+              -.5 -.5 -.5
+              -.5 -.5 .5
+              .5 -.5 .5
+              .5 -.5 -.5
+             ]
+            }
+           }
+          }
+         ]
+        }
+        DEF dad_Box2 Transform {
+         translation 0 0 -5.5
+         children [
+          DEF Box2 Shape {
+           appearance Appearance {
+            material DEF Purple Material {
+             ambientIntensity 0.200
+             shininess 0.200
+             diffuseColor .9176 0 .874
+            }
+           }
+           geometry DEF GeoBox2 Box {
+            size 2.8 2.8 1.5
+           }
+          }
+         ]
+        }
+        DEF dad_Box6 Transform {
+         translation 0 1.25 -5.5
+         children [
+          DEF Box6 Shape {
+           appearance Appearance {
+            material USE Purple
+           }
+           geometry DEF GeoBox21 Box {
+            size .25 1 1.5
+           }
+          }
+         ]
+        }
+       ]
+      }
+      DEF dad_Cylinder2 Transform {
+       rotation 0 0 1 1.571
+       scale 1.1 1.5 1.1
+       children [
+        DEF Cylinder2 Shape {
+         appearance Appearance {
+          material DEF Green Material {
+           ambientIntensity 0.200
+           shininess 0.200
+           diffuseColor .00784 .65098 .02353
+          }
+         }
+         geometry DEF Cylinder2_Geo IndexedFaceSet {
+          creaseAngle 0.524
+          coordIndex [
+            49 50 48 -1 
+            48 50 51 -1 
+            48 51 47 -1 
+            47 51 20 -1 
+            47 20 21 -1 
+            12 13 56 -1 
+            56 13 14 -1 
+            56 14 55 -1 
+            55 14 15 -1 
+            55 15 54 -1 
+            54 15 16 -1 
+            54 16 53 -1 
+            53 16 17 -1 
+            53 17 52 -1 
+            52 17 18 -1 
+            52 18 51 -1 
+            51 18 19 -1 
+            51 19 20 -1 
+            5 6 62 -1 
+            62 6 7 -1 
+            62 7 61 -1 
+            61 7 8 -1 
+            61 8 60 -1 
+            60 8 9 -1 
+            60 9 59 -1 
+            59 9 10 -1 
+            59 10 58 -1 
+            58 10 11 -1 
+            58 11 57 -1 
+            57 11 12 -1 
+            57 12 56 -1 
+            5 63 4 -1 
+            4 63 64 -1 
+            4 64 3 -1 
+            3 64 1 -1 
+            3 1 2 -1 
+            2 1 35 -1 
+            2 35 36 -1 
+            28 41 27 -1 
+            27 41 42 -1 
+            27 42 26 -1 
+            26 42 43 -1 
+            26 43 25 -1 
+            25 43 44 -1 
+            25 44 24 -1 
+            24 44 45 -1 
+            24 45 23 -1 
+            23 45 46 -1 
+            23 46 22 -1 
+            22 46 47 -1 
+            22 47 21 -1 
+            34 36 33 -1 
+            33 36 37 -1 
+            33 37 32 -1 
+            32 37 38 -1 
+            32 38 31 -1 
+            31 38 39 -1 
+            31 39 30 -1 
+            30 39 40 -1 
+            30 40 29 -1 
+            29 40 41 -1 
+            29 41 28 -1 
+            1 64 0 -1 
+            2 36 34 -1 
+            63 5 62 -1 
+            95 96 97 -1 
+            97 96 65 -1 
+            97 65 129 -1 
+            129 65 66 -1 
+            129 66 128 -1 
+            128 66 67 -1 
+            128 67 127 -1 
+            127 67 126 -1 
+            104 105 88 -1 
+            88 105 106 -1 
+            88 106 87 -1 
+            87 106 107 -1 
+            87 107 86 -1 
+            86 107 108 -1 
+            86 108 85 -1 
+            85 108 109 -1 
+            85 109 84 -1 
+            84 109 110 -1 
+            84 110 83 -1 
+            83 110 111 -1 
+            83 111 82 -1 
+            82 111 112 -1 
+            82 112 113 -1 
+            98 99 93 -1 
+            93 99 100 -1 
+            93 100 92 -1 
+            92 100 101 -1 
+            92 101 91 -1 
+            91 101 102 -1 
+            91 102 90 -1 
+            90 102 103 -1 
+            90 103 89 -1 
+            89 103 104 -1 
+            89 104 88 -1 
+            94 95 97 -1 
+            94 97 98 -1 
+            94 98 93 -1 
+            81 82 78 -1 
+            81 78 79 -1 
+            81 79 80 -1 
+            78 82 113 -1 
+            78 113 114 -1 
+            78 114 115 -1 
+            78 115 77 -1 
+            120 73 119 -1 
+            119 73 74 -1 
+            119 74 118 -1 
+            118 74 75 -1 
+            118 75 117 -1 
+            117 75 76 -1 
+            117 76 116 -1 
+            116 76 77 -1 
+            116 77 115 -1 
+            126 68 125 -1 
+            125 68 69 -1 
+            125 69 124 -1 
+            124 69 70 -1 
+            124 70 123 -1 
+            123 70 71 -1 
+            123 71 122 -1 
+            122 71 72 -1 
+            122 72 121 -1 
+            121 72 73 -1 
+            121 73 120 -1 
+            126 67 68 -1 
+            0 64 65 -1 
+            0 65 96 -1 
+            64 63 66 -1 
+            64 66 65 -1 
+            63 62 67 -1 
+            63 67 66 -1 
+            62 61 68 -1 
+            62 68 67 -1 
+            61 60 69 -1 
+            61 69 68 -1 
+            60 59 70 -1 
+            60 70 69 -1 
+            59 58 71 -1 
+            59 71 70 -1 
+            58 57 72 -1 
+            58 72 71 -1 
+            57 56 73 -1 
+            57 73 72 -1 
+            56 55 74 -1 
+            56 74 73 -1 
+            55 54 75 -1 
+            55 75 74 -1 
+            54 53 76 -1 
+            54 76 75 -1 
+            53 52 77 -1 
+            53 77 76 -1 
+            52 51 78 -1 
+            52 78 77 -1 
+            51 50 79 -1 
+            51 79 78 -1 
+            50 49 80 -1 
+            50 80 79 -1 
+            49 48 81 -1 
+            49 81 80 -1 
+            48 47 82 -1 
+            48 82 81 -1 
+            47 46 83 -1 
+            47 83 82 -1 
+            46 45 84 -1 
+            46 84 83 -1 
+            45 44 85 -1 
+            45 85 84 -1 
+            44 43 86 -1 
+            44 86 85 -1 
+            43 42 87 -1 
+            43 87 86 -1 
+            42 41 88 -1 
+            42 88 87 -1 
+            41 40 89 -1 
+            41 89 88 -1 
+            40 39 90 -1 
+            40 90 89 -1 
+            39 38 91 -1 
+            39 91 90 -1 
+            38 37 92 -1 
+            38 92 91 -1 
+            37 36 93 -1 
+            37 93 92 -1 
+            36 35 94 -1 
+            36 94 93 -1 
+            35 1 95 -1 
+            35 95 94 -1 
+            1 0 96 -1 
+            1 96 95 -1 
+          ]
+          coord DEF Cylinder2_Coord Coordinate {
+           point [
+            0 1 -6
+            -1.17054 1 -5.88471
+            -1.07212 1 -5.3899
+            -1.05189 1 -5.39596
+            .02145 1 -5.49809
+            1.09408 1 -5.38886
+            2.1248 1 -5.07248
+            3.07398 1 -4.56108
+            3.90517 1 -3.87434
+            4.5864 1 -3.03864
+            5.0915 1 -2.08609
+            5.40107 1 -1.0533
+            5.5032 1 .02003
+            5.39398 1 1.09267
+            5.07759 1 2.12338
+            4.5662 1 3.07257
+            3.87945 1 3.90375
+            3.04375 1 4.58498
+            2.0912 1 5.09009
+            1.05842 1 5.39966
+            -.01492 1 5.50179
+            -1.08755 1 5.39256
+            -2.11827 1 5.07617
+            -3.06746 1 4.56478
+            -3.89864 1 3.87804
+            -4.57987 1 3.04233
+            -5.08498 1 2.08979
+            -5.39454 1 1.057
+            -5.49668 1 -.01633
+            -5.38745 1 -1.08897
+            -5.07106 1 -2.11968
+            -4.55967 1 -3.06887
+            -3.87292 1 -3.90005
+            -3.03722 1 -4.58129
+            -2.08467 1 -5.08639
+            -2.2961 1 -5.54328
+            -3.33342 1 -4.98882
+            -4.24264 1 -4.24264
+            -4.98882 1 -3.33342
+            -5.54328 1 -2.2961
+            -5.88471 1 -1.17054
+            -6 1 -0
+            -5.88471 1 1.17054
+            -5.54328 1 2.2961
+            -4.98882 1 3.33342
+            -4.24264 1 4.24264
+            -3.33342 1 4.98882
+            -2.2961 1 5.54328
+            -1.17054 1 5.88471
+            -0 1 6
+            1.17054 1 5.88471
+            2.2961 1 5.54328
+            3.33342 1 4.98882
+            4.24264 1 4.24264
+            4.98882 1 3.33342
+            5.54328 1 2.2961
+            5.88471 1 1.17054
+            6 1 0
+            5.88471 1 -1.17054
+            5.54328 1 -2.2961
+            4.98882 1 -3.33342
+            4.24264 1 -4.24264
+            3.33342 1 -4.98882
+            2.2961 1 -5.54328
+            1.17054 1 -5.88471
+            1.17054 -1 -5.88471
+            2.2961 -1 -5.54328
+            3.33342 -1 -4.98882
+            4.24264 -1 -4.24264
+            4.98882 -1 -3.33342
+            5.54328 -1 -2.2961
+            5.88471 -1 -1.17054
+            6 -1 -0
+            5.88471 -1 1.17054
+            5.54328 -1 2.2961
+            4.98882 -1 3.33342
+            4.24264 -1 4.24264
+            3.33342 -1 4.98882
+            2.2961 -1 5.54328
+            1.17054 -1 5.88471
+            -0 -1 6
+            -1.17054 -1 5.88471
+            -2.2961 -1 5.54328
+            -3.33342 -1 4.98882
+            -4.24264 -1 4.24264
+            -4.98882 -1 3.33342
+            -5.54328 -1 2.2961
+            -5.88471 -1 1.17054
+            -6 -1 -0
+            -5.88471 -1 -1.17054
+            -5.54328 -1 -2.2961
+            -4.98882 -1 -3.33342
+            -4.24264 -1 -4.24264
+            -3.33342 -1 -4.98882
+            -2.2961 -1 -5.54328
+            -1.17054 -1 -5.88471
+            0 -1 -6
+            0 -1 -5.50037
+            -1.05842 -1 -5.39966
+            -2.0912 -1 -5.09009
+            -3.04375 -1 -4.58498
+            -3.87945 -1 -3.90375
+            -4.5662 -1 -3.07257
+            -5.07759 -1 -2.12338
+            -5.39398 -1 -1.09267
+            -5.5032 -1 -.02003
+            -5.40107 -1 1.0533
+            -5.0915 -1 2.08609
+            -4.5864 -1 3.03864
+            -3.90517 -1 3.87434
+            -3.07398 -1 4.56108
+            -2.1248 -1 5.07248
+            -1.09408 -1 5.38886
+            -.02145 -1 5.49809
+            1.05189 -1 5.39596
+            2.08467 -1 5.08639
+            3.03722 -1 4.58129
+            3.87292 -1 3.90005
+            4.55967 -1 3.06887
+            5.07106 -1 2.11968
+            5.38745 -1 1.08897
+            5.49668 -1 .01633
+            5.39454 -1 -1.057
+            5.08498 -1 -2.08979
+            4.57987 -1 -3.04233
+            3.89864 -1 -3.87804
+            3.06746 -1 -4.56478
+            2.11827 -1 -5.07617
+            1.08755 -1 -5.39256
+            .01492 -1 -5.50179
+           ]
+          }
+         }
+        }
+       ]
+      }
+      DEF dad_Cylinder3 Transform {
+       rotation 0 0 1 1.571
+       scale 1.1 1.5 1.1
+       children [
+        DEF Cylinder3 Shape {
+         appearance Appearance {
+          material USE Green
+         }
+         geometry DEF Cylinder3_Geo IndexedFaceSet {
+          creaseAngle 0.524
+          coordIndex [
+            0 1 2 -1 
+            0 2 3 -1 
+            4 5 1 -1 
+            4 1 0 -1 
+            6 7 5 -1 
+            6 5 4 -1 
+            8 9 7 -1 
+            8 7 6 -1 
+            10 11 9 -1 
+            10 9 8 -1 
+            12 13 11 -1 
+            12 11 10 -1 
+            14 15 13 -1 
+            14 13 12 -1 
+            16 17 15 -1 
+            16 15 14 -1 
+            18 19 17 -1 
+            18 17 16 -1 
+            20 21 19 -1 
+            20 19 18 -1 
+            22 23 21 -1 
+            22 21 20 -1 
+            24 25 23 -1 
+            24 23 22 -1 
+            26 27 25 -1 
+            26 25 24 -1 
+            28 29 27 -1 
+            28 27 26 -1 
+            30 31 29 -1 
+            30 29 28 -1 
+            32 33 31 -1 
+            32 31 30 -1 
+            34 35 33 -1 
+            34 33 32 -1 
+            36 37 35 -1 
+            36 35 34 -1 
+            38 39 37 -1 
+            38 37 36 -1 
+            40 41 39 -1 
+            40 39 38 -1 
+            42 43 41 -1 
+            42 41 40 -1 
+            44 45 43 -1 
+            44 43 42 -1 
+            46 47 45 -1 
+            46 45 44 -1 
+            48 49 47 -1 
+            48 47 46 -1 
+            50 51 49 -1 
+            50 49 48 -1 
+            52 53 51 -1 
+            52 51 50 -1 
+            54 55 53 -1 
+            54 53 52 -1 
+            56 57 55 -1 
+            56 55 54 -1 
+            58 59 57 -1 
+            58 57 56 -1 
+            60 61 59 -1 
+            60 59 58 -1 
+            62 63 61 -1 
+            62 61 60 -1 
+            3 2 63 -1 
+            3 63 62 -1 
+          ]
+          coord DEF Cylinder3_Coord Coordinate {
+           point [
+            1.073 -1.00635 -5.39432
+            1.073 .99367 -5.39432
+            0 .98997 -5.5
+            0 -1.01006 -5.5
+            2.10476 -1.0024 -5.08134
+            2.10476 .99763 -5.08134
+            3.05564 -.99836 -4.57308
+            3.05564 1.00167 -4.57308
+            3.88909 -.99438 -3.88909
+            3.88909 1.00565 -3.88909
+            4.57308 -.99061 -3.05564
+            4.57308 1.00941 -3.05564
+            5.08134 -.98721 -2.10476
+            5.08134 1.01282 -2.10476
+            5.39432 -.9843 -1.073
+            5.39432 1.01573 -1.073
+            5.5 -.98199 -0
+            5.5 1.01803 -0
+            5.39432 -.98038 1.073
+            5.39432 1.01965 1.073
+            5.08134 -.97952 2.10476
+            5.08134 1.02051 2.10476
+            4.57308 -.97945 3.05564
+            4.57308 1.02058 3.05564
+            3.88909 -.98017 3.88909
+            3.88909 1.01986 3.88909
+            3.05564 -.98165 4.57308
+            3.05564 1.01838 4.57308
+            2.10476 -.98383 5.08134
+            2.10476 1.01619 5.08134
+            1.073 -.98664 5.39432
+            1.073 1.01338 5.39432
+            -0 -.98997 5.5
+            -0 1.01006 5.5
+            -1.073 -.99367 5.39432
+            -1.073 1.00635 5.39432
+            -2.10476 -.99763 5.08134
+            -2.10476 1.0024 5.08134
+            -3.05564 -1.00167 4.57308
+            -3.05564 .99836 4.57308
+            -3.88909 -1.00565 3.88909
+            -3.88909 .99438 3.88909
+            -4.57308 -1.00941 3.05564
+            -4.57308 .99061 3.05564
+            -5.08134 -1.01282 2.10476
+            -5.08134 .98721 2.10476
+            -5.39432 -1.01573 1.073
+            -5.39432 .9843 1.073
+            -5.5 -1.01803 -0
+            -5.5 .98199 -0
+            -5.39432 -1.01965 -1.073
+            -5.39432 .98038 -1.073
+            -5.08134 -1.02051 -2.10476
+            -5.08134 .97952 -2.10476
+            -4.57308 -1.02058 -3.05564
+            -4.57308 .97945 -3.05564
+            -3.88909 -1.01986 -3.88909
+            -3.88909 .98017 -3.88909
+            -3.05564 -1.01838 -4.57308
+            -3.05564 .98165 -4.57308
+            -2.10476 -1.01619 -5.08134
+            -2.10476 .98383 -5.08134
+            -1.073 -1.01338 -5.39432
+            -1.073 .98664 -5.39432
+           ]
+          }
+         }
+        }
+       ]
+      }
+      DEF dad_Box10 Transform {
+       translation 0 2 -8.4
+       children [
+        DEF Box10 Shape {
+         appearance Appearance {
+          material USE Green
+         }
+         geometry DEF GeoBox10 Box {
+          size .25 1 4.25
+         }
+        }
+       ]
+      }
+      DEF dad_Cylinder5 Transform {
+       translation 0 0 -8.4
+       rotation 1 0 0 1.571
+       children [
+        DEF Cylinder5 Shape {
+         appearance Appearance {
+          material USE Green
+         }
+         geometry DEF GeoCylinder5 Cylinder {
+          height 4.250
+          radius 2.000
+         }
+        }
+       ]
+      }
+     ]
+    }
+    DEF dad_lab_posttop Transform {
+     translation 0 0 -11
+     rotation -1 0 0 1.571
+     children [
+      DEF alpha_posttop Shape {
+       appearance Appearance {
+        material USE Red
+       }
+       geometry DEF GeoCylinder6 Cylinder {
+        height 1.000
+        radius 2.000
+       }
+      }
+     ]
+    }
+    DEF dad_alpha_arm Transform {
+     translation 0 -20.5 -5
+     children [
+      DEF alpha_arm Shape {
+       appearance Appearance {
+        material USE Red
+       }
+       geometry DEF GeoBox7 Box {
+        size 4 1 13
+       }
+      }
+     ]
+    }
+    DEF dad_gamma_arm1 Transform {
+     translation -6 -20.5 0
+     children [
+      DEF gamma_arm1 Shape {
+       appearance Appearance {
+        material USE Red
+       }
+       geometry DEF GeoBox18 Box {
+        size 1 2 .25
+       }
+      }
+     ]
+    }
+    DEF dad_Box12 Transform {
+     translation 0 2 -11
+     children [
+      DEF Box12 Shape {
+       appearance Appearance {
+        material USE Red
+       }
+       geometry DEF GeoBox12 Box {
+        size .25 1 1
+       }
+      }
+     ]
+    }
+   ]
+  }
+  DEF dad_gamma_frame Transform {
+   rotation 0 1 0 .349
+   children [
+    DEF dad_lab_posttop0 Transform {
+     translation 0 0 -12.5
+     rotation -1 0 0 1.571
+     children [
+      DEF gamma_posttop Shape {
+       appearance Appearance {
+        material DEF Blue Material {
+         ambientIntensity 0.200
+         shininess 0.200
+         diffuseColor 0 0 .62745
+        }
+       }
+       geometry DEF GeoCylinder4 Cylinder {
+        height 1.000
+        radius 2.000
+       }
+      }
+     ]
+    }
+    DEF dad_lab_post0 Transform {
+     translation 0 -11 -12.5
+     children [
+      DEF gamma_post Shape {
+       appearance Appearance {
+        material USE Blue
+       }
+       geometry DEF GeoBox5 Box {
+        size 4 22 1
+       }
+      }
+     ]
+    }
+    DEF dad_gamma_base Transform {
+     translation 0 -22.5 0
+     children [
+      DEF gamma_base Shape {
+       appearance Appearance {
+        material USE Blue
+       }
+       geometry DEF GeoCylinder3 Cylinder {
+        height 2.000
+        radius 8.000
+       }
+      }
+     ]
+    }
+    DEF dad_gamma_arm Transform {
+     translation 0 -22.5 -6.5
+     children [
+      DEF gamma_arm Shape {
+       appearance Appearance {
+        material USE Blue
+       }
+       geometry DEF GeoBox4 Box {
+        size 4 1 13
+       }
+      }
+     ]
+    }
+    DEF dad_delta_frame Transform {
+     rotation 0 0 1 -.524
+     children [
+      DEF dad_delta_mount Transform {
+       translation 0 0 -15
+       rotation -1 0 0 1.571
+       children [
+        DEF delta_mount Shape {
+         appearance Appearance {
+          material DEF Yellow Material {
+           ambientIntensity 0.200
+           shininess 0.200
+           diffuseColor .83529 .83529 0
+          }
+         }
+         geometry DEF GeoCylinder2 Cylinder {
+          height 4.000
+          radius 2.000
+         }
+        }
+       ]
+      }
+      DEF dad_delta_arm Transform {
+       translation -10 0 -15
+       children [
+        DEF delta_arm Shape {
+         appearance Appearance {
+          material USE Yellow
+         }
+         geometry DEF GeoBox8 Box {
+          size 20 3 1
+         }
+        }
+       ]
+      }
+      DEF dad_delta_arm0 Transform {
+       translation -20 0 -6.5
+       children [
+        DEF delta_arm0 Shape {
+         appearance Appearance {
+          material USE Yellow
+         }
+         geometry DEF GeoBox6 Box {
+          size 1 3 18
+         }
+        }
+       ]
+      }
+      DEF dad_Cylinder14 Transform {
+       translation -18 0 0
+       rotation .577 -.577 .577 2.094
+       children [
+        DEF Cylinder14 Shape {
+         appearance Appearance {
+          material USE Yellow
+         }
+         geometry DEF GeoCylinder14 Cylinder {
+          height 3.000
+          radius 1.000
+         }
+        }
+       ]
+      }
+      DEF dad_detector_beam Transform {
+       translation -10 0 0
+       rotation 0 0 1 1.571
+       children [
+        DEF detector_beam Shape {
+         appearance Appearance {
+          material USE White
+         }
+         geometry DEF GeoCylinder21 Cylinder {
+          height 20.000
+          radius 0.050
+         }
+        }
+       ]
+      }
+      DEF dad_Box13 Transform {
+       translation 0 2 -15
+       children [
+        DEF Box13 Shape {
+         appearance Appearance {
+          material USE Yellow
+         }
+         geometry DEF GeoBox13 Box {
+          size .25 1 4
+         }
+        }
+       ]
+      }
+     ]
+    }
+    DEF dad_gamma_arm0 Transform {
+     translation -8 -22.5 0
+     children [
+      DEF gamma_arm0 Shape {
+       appearance Appearance {
+        material USE Blue
+       }
+       geometry DEF GeoBox17 Box {
+        size 1 2 .25
+       }
+      }
+     ]
+    }
+    DEF dad_Box14 Transform {
+     translation 0 2 -12.5
+     children [
+      DEF Box14 Shape {
+       appearance Appearance {
+        material USE Blue
+       }
+       geometry DEF GeoBox14 Box {
+        size .25 1 1
+       }
+      }
+     ]
+    }
+   ]
+  }
+  DEF dad_gamma_arm2 Transform {
+   translation -9 -24.5 0
+   children [
+    DEF gamma_arm2 Shape {
+     appearance Appearance {
+      material DEF Black Material {
+       ambientIntensity 0.200
+       shininess 0.200
+       diffuseColor .20784 .20784 .20784
+      }
+     }
+     geometry DEF GeoBox19 Box {
+      size 1 2 .25
+     }
+    }
+   ]
+  }
+  DEF dad_gamma_base0 Transform {
+   translation 0 -24.5 0
+   rotation 0 1 0 .349
+   children [
+    DEF gamma_base0 Shape {
+     appearance Appearance {
+      material USE Black
+     }
+     geometry DEF GeoCylinder9 Cylinder {
+      height 2.000
+      radius 9.000
+     }
+    }
+   ]
+  }
+  DEF dad_floor Transform {
+   translation 0 -25.5 0
+   children [
+    DEF floor Shape {
+     appearance Appearance {
+      material USE Black
+     }
+     geometry DEF GeoBox16 Box {
+      size 60 .2 40
+     }
+    }
+   ]
+  }
+  DEF VP Viewpoint {
+   description "VP"
+   jump TRUE
+   fieldOfView 1.165
+   position 40 40 40
+   orientation -.754 .657 -0 1.001
+  }
+ ]
+}
diff --git a/script/test/diffcalc (copy)/model/vrml_animator.py b/script/test/diffcalc (copy)/model/vrml_animator.py
new file mode 100644
index 0000000..d283469
--- /dev/null
+++ b/script/test/diffcalc (copy)/model/vrml_animator.py	
@@ -0,0 +1,134 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import sys
+import time
+import threading
+from math import pi
+import socket
+
+from pivy.coin import *
+from pivy.sogui import *
+
+
+PORT = 4567
+TORAD = pi / 180
+
+
+def connect_to_socket(host, port):
+    print "Connecting to %s on port %d" % (host, port)
+    connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    print "Connected"
+    connection.connect((host, port))
+    socketfile = connection.makefile('rw', 0)
+    return socketfile
+
+
+def serve_socket_connection(port):
+    print ("Serving connection on all interfaces on %s port %d" %
+           (socket.gethostname(), port))
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.bind((socket.gethostname(), port))
+    sock.listen(1)
+    time.sleep(1)
+    (connection, addr) = sock.accept()
+    print 'Connected from ', addr, ' accepted'
+    socket_file = connection.makefile('rw', 0)  # no buffering
+    return socket_file
+
+
+def node_name(anglename):
+    return 'dad_' + anglename + '_frame'
+
+
+class SceneUpdatingThread(threading.Thread):
+
+    def __init__(self, scene, axisnames):
+        threading.Thread.__init__(self)
+        self.scene = scene
+
+        # Infer rotation axes based on initial orientation
+        self.rotation_axes = {}
+        self.axies_nodes = {}
+        for axisname in axisnames:
+            node = self.scene.getByName(node_name(axisname))
+            self.axies_nodes[axisname] = node
+            value = node.rotation.getValue()
+            self.rotation_axes[axisname] = value.getAxisAngle()[0]
+
+    def run(self):
+        socket_file = serve_socket_connection(PORT)
+
+        while True:
+            msg = socket_file.readline()
+            if msg == '':
+                print '***Socket closed'
+                socket_file = serve_socket_connection(PORT)
+                continue
+            print msg.strip()
+            d = eval(msg.strip())  # msg should be a dictionary representation
+            for axisname in d:
+                self.set_axis_rotation(axisname, d[axisname])
+
+    def set_axis_rotation(self, anglename, degrees):
+        nodename = node_name(anglename)
+        angle = degrees * TORAD
+        while angle < 0:
+            angle = 2 * pi + angle
+        node = self.scene.getByName(nodename)
+        getattr(node, 'rotation').setValue(
+            self.rotation_axes[anglename], angle)
+
+
+class Animator(object):
+
+    def __init__(self, filename, axisnames):
+        print "filename : " + filename
+        print "    axes : " + ' '.join(axisnames)
+        # Create viewer
+        self.myWindow = SoGui.init(sys.argv[0])  # @UndefinedVariable
+        if self.myWindow is None: sys.exit(1)
+        viewer = SoGuiExaminerViewer(self.myWindow)  # @UndefinedVariable
+        # load file into scene
+        so_input = SoInput()  # @UndefinedVariable
+        so_input.openFile(filename)
+        self.scene = SoDB.readAll(so_input)  # @UndefinedVariable
+        # Add scene to viewer
+        viewer.setSceneGraph(self.scene)
+        viewer.setTitle(' '.join(axisnames))
+        viewer.show()
+
+        self.start_update_scene_thread(axisnames)
+
+    def start_update_scene_thread(self, axisnames):
+        t = SceneUpdatingThread(self.scene, axisnames)
+        t.setDaemon(True)
+        t.start()
+
+    def show(self):
+        SoGui.show(self.myWindow)  # @UndefinedVariable
+        SoGui.mainLoop()  # @UndefinedVariable
+
+def main():
+    animator = Animator(sys.argv[1], sys.argv[2:])
+    animator.show()
+
+if __name__ == "__main__":
+    main()
+
diff --git a/script/test/diffcalc (copy)/numjy/__init__.py b/script/test/diffcalc (copy)/numjy/__init__.py
new file mode 100644
index 0000000..273b233
--- /dev/null
+++ b/script/test/diffcalc (copy)/numjy/__init__.py	
@@ -0,0 +1,36 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+try:
+    import Jama
+    from numjy import linalg
+    from numjy.jama_matrix_wrapper import matrix
+    JAMA = True
+except ImportError:
+    JAMA = False
+
+
+def hstack(list_of_column_matrices):
+    if not Jama:
+        raise Exception('Jama not available, use numpy directly')
+    ncol = len(list_of_column_matrices)
+    nrow = list_of_column_matrices[0].shape[0]
+    m = Jama.Matrix(nrow, ncol)
+    for c, column_matrix in enumerate(list_of_column_matrices):
+        m.setMatrix(0, nrow - 1, c, c, column_matrix.m)
+    return matrix(m)
diff --git a/script/test/diffcalc (copy)/numjy/jama_matrix_wrapper.py b/script/test/diffcalc (copy)/numjy/jama_matrix_wrapper.py
new file mode 100644
index 0000000..d5e7645
--- /dev/null
+++ b/script/test/diffcalc (copy)/numjy/jama_matrix_wrapper.py	
@@ -0,0 +1,120 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import Jama
+
+
+class matrix(object):
+
+    def __init__(self, a):
+        if isinstance(a, Jama.Matrix):
+            self.m = a
+        elif isinstance(a, basestring):
+            l = []
+            for row in a.strip().split(';'):
+                l.append([float(element)
+                          for element in row.replace(',', ' ').split()])
+            self.m = Jama.Matrix(l)
+        elif isinstance(a, matrix):
+            self.m = Jama.Matrix(a.m)
+        elif isinstance(a, (list, tuple)):
+            if isinstance(a[0], (list, tuple)):
+                # a is a list of lists (not rigorous test!)
+                self.m = Jama.Matrix(a)
+            else:
+                # a is a row vector
+                self.m = Jama.Matrix([a])
+        else:
+            # give it a go
+            self.m = Jama.Matrix(a)
+
+    def __eq__(self, other):
+        nrow, ncol = self.shape
+        b = matrix(Jama.Matrix(nrow, ncol))
+        for i in range(nrow):
+            for j in range(ncol):
+                b[i, j] = self[i, j] == other[i, j]
+        return b
+
+    @property
+    def shape(self):
+        return self.m.getRowDimension(), self.m.getColumnDimension()
+
+    def __len__(self):
+        return self.m.getRowDimension()
+
+    def all(self):  # @ReservedAssignment
+        for row in self.m.array:
+            if not all(row):
+                return False
+        return True
+
+    def tolist(self):
+        l = []
+        nrow, ncol = self.shape
+        for i in range(nrow):
+            row = []
+            for j in range(ncol):
+                row.append(self[i, j])
+            l.append(row)
+        return l
+
+    def sum(self):  # @ReservedAssignment
+        return sum(sum(row) for row in self.m.array)
+
+    @property
+    def I(self):
+        return matrix(self.m.inverse())
+
+    @property
+    def T(self):
+        return matrix(self.m.transpose())
+
+    def _scaler(self, scaler):
+        return Jama.Matrix(self.shape[0], self.shape[1], scaler)
+
+    def __add__(self, other):
+        v = other.m if isinstance(other, matrix) else self._scaler(other)
+        return matrix(self.m.plus(v))
+
+    def __sub__(self, other):
+        v = other.m if isinstance(other, matrix) else self._scaler(other)
+        return matrix(self.m.minus(v))
+
+    def __mul__(self, other):
+        return matrix(self.m.times(other.m if isinstance(other, matrix) else
+                                   other))
+
+    def __div__(self, other):
+        # dividend = other.I if isinstance(other, matrix) else 1. /float(other)
+        return self.__mul__(1. / float(other))
+
+    def __getitem__(self, key):
+        i, j = key
+        return self.m.get(i, j)
+
+    def __setitem__(self, key, value):
+        i, j = key
+        self.m.set(i, j, value)
+
+    def __str__(self):
+        insides = ['  '.join([str(el) for el in row]) for row in self.tolist()]
+        return '[[' + ']\n ['.join(insides) + ']]'
+
+    def __repr__(self):
+        return 'matrix(' + '\n       '.join(self.__str__().split('\n')) + ')'
diff --git a/script/test/diffcalc (copy)/numjy/linalg.py b/script/test/diffcalc (copy)/numjy/linalg.py
new file mode 100644
index 0000000..218d824
--- /dev/null
+++ b/script/test/diffcalc (copy)/numjy/linalg.py	
@@ -0,0 +1,20 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+def norm(mat):
+    return mat.m.normF()
diff --git a/script/test/diffcalc (copy)/setup.py b/script/test/diffcalc (copy)/setup.py
new file mode 100644
index 0000000..0d549da
--- /dev/null
+++ b/script/test/diffcalc (copy)/setup.py	
@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='diffcalc',
+    version='2.1',
+    
+    description='A diffraction condition calculator for X-ray or neutron diffractometer control.',
+    long_description=open('README.rst').read(),
+    url='https://github.com/DiamondLightSource/diffcalc',
+    
+    author='Rob Walton',
+    author_email='rob.walton@diamond.ac.uk',
+    
+    license='GNU',
+    
+    packages=find_packages(exclude=['docs']),
+    
+    install_requires=[         
+        'numpy',
+        'ipython',
+        'pytest',
+        'pytest-xdist',
+        'nose'
+    ],
+
+    entry_points={
+        'console_scripts': [
+            'diffcalc=diffcmd.diffcalc_launcher:main',
+        ],
+    },
+)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/simplejson/__init__.py b/script/test/diffcalc (copy)/simplejson/__init__.py
new file mode 100644
index 0000000..fe2bd5a
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/__init__.py	
@@ -0,0 +1,510 @@
+r"""JSON (JavaScript Object Notation) <http://json.org> is a subset of
+JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
+interchange format.
+
+:mod:`simplejson` exposes an API familiar to users of the standard library
+:mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
+version of the :mod:`json` library contained in Python 2.6, but maintains
+compatibility with Python 2.4 and Python 2.5 and (currently) has
+significant performance advantages, even without using the optional C
+extension for speedups.
+
+Encoding basic Python object hierarchies::
+
+    >>> import simplejson as json
+    >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
+    '["foo", {"bar": ["baz", null, 1.0, 2]}]'
+    >>> print json.dumps("\"foo\bar")
+    "\"foo\bar"
+    >>> print json.dumps(u'\u1234')
+    "\u1234"
+    >>> print json.dumps('\\')
+    "\\"
+    >>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
+    {"a": 0, "b": 0, "c": 0}
+    >>> from StringIO import StringIO
+    >>> io = StringIO()
+    >>> json.dump(['streaming API'], io)
+    >>> io.getvalue()
+    '["streaming API"]'
+
+Compact encoding::
+
+    >>> import simplejson as json
+    >>> json.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))
+    '[1,2,3,{"4":5,"6":7}]'
+
+Pretty printing::
+
+    >>> import simplejson as json
+    >>> s = json.dumps({'4': 5, '6': 7}, sort_keys=True, indent='    ')
+    >>> print '\n'.join([l.rstrip() for l in  s.splitlines()])
+    {
+        "4": 5,
+        "6": 7
+    }
+
+Decoding JSON::
+
+    >>> import simplejson as json
+    >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
+    >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
+    True
+    >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar'
+    True
+    >>> from StringIO import StringIO
+    >>> io = StringIO('["streaming API"]')
+    >>> json.load(io)[0] == 'streaming API'
+    True
+
+Specializing JSON object decoding::
+
+    >>> import simplejson as json
+    >>> def as_complex(dct):
+    ...     if '__complex__' in dct:
+    ...         return complex(dct['real'], dct['imag'])
+    ...     return dct
+    ...
+    >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
+    ...     object_hook=as_complex)
+    (1+2j)
+    >>> from decimal import Decimal
+    >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
+    True
+
+Specializing JSON object encoding::
+
+    >>> import simplejson as json
+    >>> def encode_complex(obj):
+    ...     if isinstance(obj, complex):
+    ...         return [obj.real, obj.imag]
+    ...     raise TypeError(repr(o) + " is not JSON serializable")
+    ...
+    >>> json.dumps(2 + 1j, default=encode_complex)
+    '[2.0, 1.0]'
+    >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
+    '[2.0, 1.0]'
+    >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
+    '[2.0, 1.0]'
+
+
+Using simplejson.tool from the shell to validate and pretty-print::
+
+    $ echo '{"json":"obj"}' | python -m simplejson.tool
+    {
+        "json": "obj"
+    }
+    $ echo '{ 1.2:3.4}' | python -m simplejson.tool
+    Expecting property name: line 1 column 2 (char 2)
+"""
+__version__ = '2.6.2'
+__all__ = [
+    'dump', 'dumps', 'load', 'loads',
+    'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
+    'OrderedDict', 'simple_first',
+]
+
+__author__ = 'Bob Ippolito <bob@redivi.com>'
+
+from decimal import Decimal
+
+from decoder import JSONDecoder, JSONDecodeError
+from encoder import JSONEncoder, JSONEncoderForHTML
+def _import_OrderedDict():
+    import collections
+    try:
+        return collections.OrderedDict
+    except AttributeError:
+        import ordered_dict
+        return ordered_dict.OrderedDict
+OrderedDict = _import_OrderedDict()
+
+def _import_c_make_encoder():
+    try:
+        from simplejson._speedups import make_encoder
+        return make_encoder
+    except ImportError:
+        return None
+
+_default_encoder = JSONEncoder(
+    skipkeys=False,
+    ensure_ascii=True,
+    check_circular=True,
+    allow_nan=True,
+    indent=None,
+    separators=None,
+    encoding='utf-8',
+    default=None,
+    use_decimal=True,
+    namedtuple_as_object=True,
+    tuple_as_array=True,
+    bigint_as_string=False,
+    item_sort_key=None,
+)
+
+def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
+        allow_nan=True, cls=None, indent=None, separators=None,
+        encoding='utf-8', default=None, use_decimal=True,
+        namedtuple_as_object=True, tuple_as_array=True,
+        bigint_as_string=False, sort_keys=False, item_sort_key=None,
+        **kw):
+    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
+    ``.write()``-supporting file-like object).
+
+    If ``skipkeys`` is true then ``dict`` keys that are not basic types
+    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
+    will be skipped instead of raising a ``TypeError``.
+
+    If ``ensure_ascii`` is false, then the some chunks written to ``fp``
+    may be ``unicode`` instances, subject to normal Python ``str`` to
+    ``unicode`` coercion rules. Unless ``fp.write()`` explicitly
+    understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
+    to cause an error.
+
+    If ``check_circular`` is false, then the circular reference check
+    for container types will be skipped and a circular reference will
+    result in an ``OverflowError`` (or worse).
+
+    If ``allow_nan`` is false, then it will be a ``ValueError`` to
+    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
+    in strict compliance of the JSON specification, instead of using the
+    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+    If *indent* is a string, then JSON array elements and object members
+    will be pretty-printed with a newline followed by that string repeated
+    for each level of nesting. ``None`` (the default) selects the most compact
+    representation without any newlines. For backwards compatibility with
+    versions of simplejson earlier than 2.1.0, an integer is also accepted
+    and is converted to a string with that many spaces.
+
+    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
+    then it will be used instead of the default ``(', ', ': ')`` separators.
+    ``(',', ':')`` is the most compact JSON representation.
+
+    ``encoding`` is the character encoding for str instances, default is UTF-8.
+
+    ``default(obj)`` is a function that should return a serializable version
+    of obj or raise TypeError. The default simply raises TypeError.
+
+    If *use_decimal* is true (default: ``True``) then decimal.Decimal
+    will be natively serialized to JSON with full precision.
+
+    If *namedtuple_as_object* is true (default: ``True``),
+    :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
+    as JSON objects.
+
+    If *tuple_as_array* is true (default: ``True``),
+    :class:`tuple` (and subclasses) will be encoded as JSON arrays.
+
+    If *bigint_as_string* is true (default: ``False``), ints 2**53 and higher
+    or lower than -2**53 will be encoded as strings. This is to avoid the
+    rounding that happens in Javascript otherwise. Note that this is still a
+    lossy operation that will not round-trip correctly and should be used
+    sparingly.
+
+    If specified, *item_sort_key* is a callable used to sort the items in
+    each dictionary. This is useful if you want to sort items other than
+    in alphabetical order by key. This option takes precedence over
+    *sort_keys*.
+
+    If *sort_keys* is true (default: ``False``), the output of dictionaries
+    will be sorted by item.
+
+    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+    ``.default()`` method to serialize additional types), specify it with
+    the ``cls`` kwarg.
+
+    """
+    # cached encoder
+    if (not skipkeys and ensure_ascii and
+        check_circular and allow_nan and
+        cls is None and indent is None and separators is None and
+        encoding == 'utf-8' and default is None and use_decimal
+        and namedtuple_as_object and tuple_as_array
+        and not bigint_as_string and not item_sort_key and not kw):
+        iterable = _default_encoder.iterencode(obj)
+    else:
+        if cls is None:
+            cls = JSONEncoder
+        iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+            check_circular=check_circular, allow_nan=allow_nan, indent=indent,
+            separators=separators, encoding=encoding,
+            default=default, use_decimal=use_decimal,
+            namedtuple_as_object=namedtuple_as_object,
+            tuple_as_array=tuple_as_array,
+            bigint_as_string=bigint_as_string,
+            sort_keys=sort_keys,
+            item_sort_key=item_sort_key,
+            **kw).iterencode(obj)
+    # could accelerate with writelines in some versions of Python, at
+    # a debuggability cost
+    for chunk in iterable:
+        fp.write(chunk)
+
+
+def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
+        allow_nan=True, cls=None, indent=None, separators=None,
+        encoding='utf-8', default=None, use_decimal=True,
+        namedtuple_as_object=True, tuple_as_array=True,
+        bigint_as_string=False, sort_keys=False, item_sort_key=None,
+        **kw):
+    """Serialize ``obj`` to a JSON formatted ``str``.
+
+    If ``skipkeys`` is false then ``dict`` keys that are not basic types
+    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
+    will be skipped instead of raising a ``TypeError``.
+
+    If ``ensure_ascii`` is false, then the return value will be a
+    ``unicode`` instance subject to normal Python ``str`` to ``unicode``
+    coercion rules instead of being escaped to an ASCII ``str``.
+
+    If ``check_circular`` is false, then the circular reference check
+    for container types will be skipped and a circular reference will
+    result in an ``OverflowError`` (or worse).
+
+    If ``allow_nan`` is false, then it will be a ``ValueError`` to
+    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
+    strict compliance of the JSON specification, instead of using the
+    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+    If ``indent`` is a string, then JSON array elements and object members
+    will be pretty-printed with a newline followed by that string repeated
+    for each level of nesting. ``None`` (the default) selects the most compact
+    representation without any newlines. For backwards compatibility with
+    versions of simplejson earlier than 2.1.0, an integer is also accepted
+    and is converted to a string with that many spaces.
+
+    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
+    then it will be used instead of the default ``(', ', ': ')`` separators.
+    ``(',', ':')`` is the most compact JSON representation.
+
+    ``encoding`` is the character encoding for str instances, default is UTF-8.
+
+    ``default(obj)`` is a function that should return a serializable version
+    of obj or raise TypeError. The default simply raises TypeError.
+
+    If *use_decimal* is true (default: ``True``) then decimal.Decimal
+    will be natively serialized to JSON with full precision.
+
+    If *namedtuple_as_object* is true (default: ``True``),
+    :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
+    as JSON objects.
+
+    If *tuple_as_array* is true (default: ``True``),
+    :class:`tuple` (and subclasses) will be encoded as JSON arrays.
+
+    If *bigint_as_string* is true (not the default), ints 2**53 and higher
+    or lower than -2**53 will be encoded as strings. This is to avoid the
+    rounding that happens in Javascript otherwise.
+
+    If specified, *item_sort_key* is a callable used to sort the items in
+    each dictionary. This is useful if you want to sort items other than
+    in alphabetical order by key. This option takes precendence over
+    *sort_keys*.
+
+    If *sort_keys* is true (default: ``False``), the output of dictionaries
+    will be sorted by item.
+
+    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+    ``.default()`` method to serialize additional types), specify it with
+    the ``cls`` kwarg.
+
+    """
+    # cached encoder
+    if (not skipkeys and ensure_ascii and
+        check_circular and allow_nan and
+        cls is None and indent is None and separators is None and
+        encoding == 'utf-8' and default is None and use_decimal
+        and namedtuple_as_object and tuple_as_array
+        and not bigint_as_string and not sort_keys
+        and not item_sort_key and not kw):
+        return _default_encoder.encode(obj)
+    if cls is None:
+        cls = JSONEncoder
+    return cls(
+        skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+        check_circular=check_circular, allow_nan=allow_nan, indent=indent,
+        separators=separators, encoding=encoding, default=default,
+        use_decimal=use_decimal,
+        namedtuple_as_object=namedtuple_as_object,
+        tuple_as_array=tuple_as_array,
+        bigint_as_string=bigint_as_string,
+        sort_keys=sort_keys,
+        item_sort_key=item_sort_key,
+        **kw).encode(obj)
+
+
+_default_decoder = JSONDecoder(encoding=None, object_hook=None,
+                               object_pairs_hook=None)
+
+
+def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
+        parse_int=None, parse_constant=None, object_pairs_hook=None,
+        use_decimal=False, namedtuple_as_object=True, tuple_as_array=True,
+        **kw):
+    """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
+    a JSON document) to a Python object.
+
+    *encoding* determines the encoding used to interpret any
+    :class:`str` objects decoded by this instance (``'utf-8'`` by
+    default).  It has no effect when decoding :class:`unicode` objects.
+
+    Note that currently only encodings that are a superset of ASCII work,
+    strings of other encodings should be passed in as :class:`unicode`.
+
+    *object_hook*, if specified, will be called with the result of every
+    JSON object decoded and its return value will be used in place of the
+    given :class:`dict`.  This can be used to provide custom
+    deserializations (e.g. to support JSON-RPC class hinting).
+
+    *object_pairs_hook* is an optional function that will be called with
+    the result of any object literal decode with an ordered list of pairs.
+    The return value of *object_pairs_hook* will be used instead of the
+    :class:`dict`.  This feature can be used to implement custom decoders
+    that rely on the order that the key and value pairs are decoded (for
+    example, :func:`collections.OrderedDict` will remember the order of
+    insertion). If *object_hook* is also defined, the *object_pairs_hook*
+    takes priority.
+
+    *parse_float*, if specified, will be called with the string of every
+    JSON float to be decoded.  By default, this is equivalent to
+    ``float(num_str)``. This can be used to use another datatype or parser
+    for JSON floats (e.g. :class:`decimal.Decimal`).
+
+    *parse_int*, if specified, will be called with the string of every
+    JSON int to be decoded.  By default, this is equivalent to
+    ``int(num_str)``.  This can be used to use another datatype or parser
+    for JSON integers (e.g. :class:`float`).
+
+    *parse_constant*, if specified, will be called with one of the
+    following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``.  This
+    can be used to raise an exception if invalid JSON numbers are
+    encountered.
+
+    If *use_decimal* is true (default: ``False``) then it implies
+    parse_float=decimal.Decimal for parity with ``dump``.
+
+    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+    kwarg.
+
+    """
+    return loads(fp.read(),
+        encoding=encoding, cls=cls, object_hook=object_hook,
+        parse_float=parse_float, parse_int=parse_int,
+        parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,
+        use_decimal=use_decimal, **kw)
+
+
+def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
+        parse_int=None, parse_constant=None, object_pairs_hook=None,
+        use_decimal=False, **kw):
+    """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
+    document) to a Python object.
+
+    *encoding* determines the encoding used to interpret any
+    :class:`str` objects decoded by this instance (``'utf-8'`` by
+    default).  It has no effect when decoding :class:`unicode` objects.
+
+    Note that currently only encodings that are a superset of ASCII work,
+    strings of other encodings should be passed in as :class:`unicode`.
+
+    *object_hook*, if specified, will be called with the result of every
+    JSON object decoded and its return value will be used in place of the
+    given :class:`dict`.  This can be used to provide custom
+    deserializations (e.g. to support JSON-RPC class hinting).
+
+    *object_pairs_hook* is an optional function that will be called with
+    the result of any object literal decode with an ordered list of pairs.
+    The return value of *object_pairs_hook* will be used instead of the
+    :class:`dict`.  This feature can be used to implement custom decoders
+    that rely on the order that the key and value pairs are decoded (for
+    example, :func:`collections.OrderedDict` will remember the order of
+    insertion). If *object_hook* is also defined, the *object_pairs_hook*
+    takes priority.
+
+    *parse_float*, if specified, will be called with the string of every
+    JSON float to be decoded.  By default, this is equivalent to
+    ``float(num_str)``. This can be used to use another datatype or parser
+    for JSON floats (e.g. :class:`decimal.Decimal`).
+
+    *parse_int*, if specified, will be called with the string of every
+    JSON int to be decoded.  By default, this is equivalent to
+    ``int(num_str)``.  This can be used to use another datatype or parser
+    for JSON integers (e.g. :class:`float`).
+
+    *parse_constant*, if specified, will be called with one of the
+    following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``.  This
+    can be used to raise an exception if invalid JSON numbers are
+    encountered.
+
+    If *use_decimal* is true (default: ``False``) then it implies
+    parse_float=decimal.Decimal for parity with ``dump``.
+
+    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+    kwarg.
+
+    """
+    if (cls is None and encoding is None and object_hook is None and
+            parse_int is None and parse_float is None and
+            parse_constant is None and object_pairs_hook is None
+            and not use_decimal and not kw):
+        return _default_decoder.decode(s)
+    if cls is None:
+        cls = JSONDecoder
+    if object_hook is not None:
+        kw['object_hook'] = object_hook
+    if object_pairs_hook is not None:
+        kw['object_pairs_hook'] = object_pairs_hook
+    if parse_float is not None:
+        kw['parse_float'] = parse_float
+    if parse_int is not None:
+        kw['parse_int'] = parse_int
+    if parse_constant is not None:
+        kw['parse_constant'] = parse_constant
+    if use_decimal:
+        if parse_float is not None:
+            raise TypeError("use_decimal=True implies parse_float=Decimal")
+        kw['parse_float'] = Decimal
+    return cls(encoding=encoding, **kw).decode(s)
+
+
+def _toggle_speedups(enabled):
+    import simplejson.decoder as dec
+    import simplejson.encoder as enc
+    import simplejson.scanner as scan
+    c_make_encoder = _import_c_make_encoder()
+    if enabled:
+        dec.scanstring = dec.c_scanstring or dec.py_scanstring
+        enc.c_make_encoder = c_make_encoder
+        enc.encode_basestring_ascii = (enc.c_encode_basestring_ascii or
+            enc.py_encode_basestring_ascii)
+        scan.make_scanner = scan.c_make_scanner or scan.py_make_scanner
+    else:
+        dec.scanstring = dec.py_scanstring
+        enc.c_make_encoder = None
+        enc.encode_basestring_ascii = enc.py_encode_basestring_ascii
+        scan.make_scanner = scan.py_make_scanner
+    dec.make_scanner = scan.make_scanner
+    global _default_decoder
+    _default_decoder = JSONDecoder(
+        encoding=None,
+        object_hook=None,
+        object_pairs_hook=None,
+    )
+    global _default_encoder
+    _default_encoder = JSONEncoder(
+       skipkeys=False,
+       ensure_ascii=True,
+       check_circular=True,
+       allow_nan=True,
+       indent=None,
+       separators=None,
+       encoding='utf-8',
+       default=None,
+   )
+
+def simple_first(kv):
+    """Helper function to pass to item_sort_key to sort simple
+    elements to the top, then container elements.
+    """
+    return (isinstance(kv[1], (list, dict, tuple)), kv[0])
diff --git a/script/test/diffcalc (copy)/simplejson/_speedups.c b/script/test/diffcalc (copy)/simplejson/_speedups.c
new file mode 100644
index 0000000..be68b2d
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/_speedups.c	
@@ -0,0 +1,2745 @@
+#include "Python.h"
+#include "structmember.h"
+#if PY_VERSION_HEX < 0x02070000 && !defined(PyOS_string_to_double)
+#define PyOS_string_to_double json_PyOS_string_to_double
+static double
+json_PyOS_string_to_double(const char *s, char **endptr, PyObject *overflow_exception);
+static double
+json_PyOS_string_to_double(const char *s, char **endptr, PyObject *overflow_exception) {
+    double x;
+    assert(endptr == NULL);
+    assert(overflow_exception == NULL);
+    PyFPE_START_PROTECT("json_PyOS_string_to_double", return -1.0;)
+    x = PyOS_ascii_atof(s);
+    PyFPE_END_PROTECT(x)
+    return x;
+}
+#endif
+#if PY_VERSION_HEX < 0x02060000 && !defined(Py_TYPE)
+#define Py_TYPE(ob)     (((PyObject*)(ob))->ob_type)
+#endif
+#if PY_VERSION_HEX < 0x02060000 && !defined(Py_SIZE)
+#define Py_SIZE(ob)     (((PyVarObject*)(ob))->ob_size)
+#endif
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
+typedef int Py_ssize_t;
+#define PY_SSIZE_T_MAX INT_MAX
+#define PY_SSIZE_T_MIN INT_MIN
+#define PyInt_FromSsize_t PyInt_FromLong
+#define PyInt_AsSsize_t PyInt_AsLong
+#endif
+#ifndef Py_IS_FINITE
+#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
+#endif
+
+#ifdef __GNUC__
+#define UNUSED __attribute__((__unused__))
+#else
+#define UNUSED
+#endif
+
+#define DEFAULT_ENCODING "utf-8"
+
+#define PyScanner_Check(op) PyObject_TypeCheck(op, &PyScannerType)
+#define PyScanner_CheckExact(op) (Py_TYPE(op) == &PyScannerType)
+#define PyEncoder_Check(op) PyObject_TypeCheck(op, &PyEncoderType)
+#define PyEncoder_CheckExact(op) (Py_TYPE(op) == &PyEncoderType)
+
+static PyTypeObject PyScannerType;
+static PyTypeObject PyEncoderType;
+
+typedef struct _PyScannerObject {
+    PyObject_HEAD
+    PyObject *encoding;
+    PyObject *strict;
+    PyObject *object_hook;
+    PyObject *pairs_hook;
+    PyObject *parse_float;
+    PyObject *parse_int;
+    PyObject *parse_constant;
+    PyObject *memo;
+} PyScannerObject;
+
+static PyMemberDef scanner_members[] = {
+    {"encoding", T_OBJECT, offsetof(PyScannerObject, encoding), READONLY, "encoding"},
+    {"strict", T_OBJECT, offsetof(PyScannerObject, strict), READONLY, "strict"},
+    {"object_hook", T_OBJECT, offsetof(PyScannerObject, object_hook), READONLY, "object_hook"},
+    {"object_pairs_hook", T_OBJECT, offsetof(PyScannerObject, pairs_hook), READONLY, "object_pairs_hook"},
+    {"parse_float", T_OBJECT, offsetof(PyScannerObject, parse_float), READONLY, "parse_float"},
+    {"parse_int", T_OBJECT, offsetof(PyScannerObject, parse_int), READONLY, "parse_int"},
+    {"parse_constant", T_OBJECT, offsetof(PyScannerObject, parse_constant), READONLY, "parse_constant"},
+    {NULL}
+};
+
+typedef struct _PyEncoderObject {
+    PyObject_HEAD
+    PyObject *markers;
+    PyObject *defaultfn;
+    PyObject *encoder;
+    PyObject *indent;
+    PyObject *key_separator;
+    PyObject *item_separator;
+    PyObject *sort_keys;
+    PyObject *skipkeys;
+    PyObject *key_memo;
+    PyObject *Decimal;
+    int fast_encode;
+    int allow_nan;
+    int use_decimal;
+    int namedtuple_as_object;
+    int tuple_as_array;
+    int bigint_as_string;
+    PyObject *item_sort_key;
+} PyEncoderObject;
+
+static PyMemberDef encoder_members[] = {
+    {"markers", T_OBJECT, offsetof(PyEncoderObject, markers), READONLY, "markers"},
+    {"default", T_OBJECT, offsetof(PyEncoderObject, defaultfn), READONLY, "default"},
+    {"encoder", T_OBJECT, offsetof(PyEncoderObject, encoder), READONLY, "encoder"},
+    {"indent", T_OBJECT, offsetof(PyEncoderObject, indent), READONLY, "indent"},
+    {"key_separator", T_OBJECT, offsetof(PyEncoderObject, key_separator), READONLY, "key_separator"},
+    {"item_separator", T_OBJECT, offsetof(PyEncoderObject, item_separator), READONLY, "item_separator"},
+    {"sort_keys", T_OBJECT, offsetof(PyEncoderObject, sort_keys), READONLY, "sort_keys"},
+    {"skipkeys", T_OBJECT, offsetof(PyEncoderObject, skipkeys), READONLY, "skipkeys"},
+    {"key_memo", T_OBJECT, offsetof(PyEncoderObject, key_memo), READONLY, "key_memo"},
+    {"item_sort_key", T_OBJECT, offsetof(PyEncoderObject, item_sort_key), READONLY, "item_sort_key"},
+    {NULL}
+};
+
+static PyObject *
+maybe_quote_bigint(PyObject *encoded, PyObject *obj);
+
+static Py_ssize_t
+ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars);
+static PyObject *
+ascii_escape_unicode(PyObject *pystr);
+static PyObject *
+ascii_escape_str(PyObject *pystr);
+static PyObject *
+py_encode_basestring_ascii(PyObject* self UNUSED, PyObject *pystr);
+void init_speedups(void);
+static PyObject *
+scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr);
+static PyObject *
+scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr);
+static PyObject *
+_build_rval_index_tuple(PyObject *rval, Py_ssize_t idx);
+static PyObject *
+scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
+static int
+scanner_init(PyObject *self, PyObject *args, PyObject *kwds);
+static void
+scanner_dealloc(PyObject *self);
+static int
+scanner_clear(PyObject *self);
+static PyObject *
+encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
+static int
+encoder_init(PyObject *self, PyObject *args, PyObject *kwds);
+static void
+encoder_dealloc(PyObject *self);
+static int
+encoder_clear(PyObject *self);
+static int
+encoder_listencode_list(PyEncoderObject *s, PyObject *rval, PyObject *seq, Py_ssize_t indent_level);
+static int
+encoder_listencode_obj(PyEncoderObject *s, PyObject *rval, PyObject *obj, Py_ssize_t indent_level);
+static int
+encoder_listencode_dict(PyEncoderObject *s, PyObject *rval, PyObject *dct, Py_ssize_t indent_level);
+static PyObject *
+_encoded_const(PyObject *obj);
+static void
+raise_errmsg(char *msg, PyObject *s, Py_ssize_t end);
+static PyObject *
+encoder_encode_string(PyEncoderObject *s, PyObject *obj);
+static int
+_convertPyInt_AsSsize_t(PyObject *o, Py_ssize_t *size_ptr);
+static PyObject *
+_convertPyInt_FromSsize_t(Py_ssize_t *size_ptr);
+static PyObject *
+encoder_encode_float(PyEncoderObject *s, PyObject *obj);
+static int
+_is_namedtuple(PyObject *obj);
+
+#define S_CHAR(c) (c >= ' ' && c <= '~' && c != '\\' && c != '"')
+#define IS_WHITESPACE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
+
+#define MIN_EXPANSION 6
+#ifdef Py_UNICODE_WIDE
+#define MAX_EXPANSION (2 * MIN_EXPANSION)
+#else
+#define MAX_EXPANSION MIN_EXPANSION
+#endif
+
+static PyObject *
+maybe_quote_bigint(PyObject *encoded, PyObject *obj)
+{
+    static PyObject *big_long = NULL;
+    static PyObject *small_long = NULL;
+    if (big_long == NULL) {
+        big_long = PyLong_FromLongLong(1LL << 53);
+        if (big_long == NULL) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+    }
+    if (small_long == NULL) {
+        small_long = PyLong_FromLongLong(-1LL << 53);
+        if (small_long == NULL) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+    }
+    if (PyObject_RichCompareBool(obj, big_long, Py_GE) ||
+        PyObject_RichCompareBool(obj, small_long, Py_LE)) {
+        PyObject* quoted = PyString_FromFormat("\"%s\"",
+                                               PyString_AsString(encoded));
+        Py_DECREF(encoded);
+        encoded = quoted;
+    }
+    return encoded;
+}
+
+static int
+_is_namedtuple(PyObject *obj)
+{
+    int rval = 0;
+    PyObject *_asdict = PyObject_GetAttrString(obj, "_asdict");
+    if (_asdict == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+    rval = PyCallable_Check(_asdict);
+    Py_DECREF(_asdict);
+    return rval;
+}
+
+static int
+_convertPyInt_AsSsize_t(PyObject *o, Py_ssize_t *size_ptr)
+{
+    /* PyObject to Py_ssize_t converter */
+    *size_ptr = PyInt_AsSsize_t(o);
+    if (*size_ptr == -1 && PyErr_Occurred())
+        return 0;
+    return 1;
+}
+
+static PyObject *
+_convertPyInt_FromSsize_t(Py_ssize_t *size_ptr)
+{
+    /* Py_ssize_t to PyObject converter */
+    return PyInt_FromSsize_t(*size_ptr);
+}
+
+static Py_ssize_t
+ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars)
+{
+    /* Escape unicode code point c to ASCII escape sequences
+    in char *output. output must have at least 12 bytes unused to
+    accommodate an escaped surrogate pair "\uXXXX\uXXXX" */
+    output[chars++] = '\\';
+    switch (c) {
+        case '\\': output[chars++] = (char)c; break;
+        case '"': output[chars++] = (char)c; break;
+        case '\b': output[chars++] = 'b'; break;
+        case '\f': output[chars++] = 'f'; break;
+        case '\n': output[chars++] = 'n'; break;
+        case '\r': output[chars++] = 'r'; break;
+        case '\t': output[chars++] = 't'; break;
+        default:
+#ifdef Py_UNICODE_WIDE
+            if (c >= 0x10000) {
+                /* UTF-16 surrogate pair */
+                Py_UNICODE v = c - 0x10000;
+                c = 0xd800 | ((v >> 10) & 0x3ff);
+                output[chars++] = 'u';
+                output[chars++] = "0123456789abcdef"[(c >> 12) & 0xf];
+                output[chars++] = "0123456789abcdef"[(c >>  8) & 0xf];
+                output[chars++] = "0123456789abcdef"[(c >>  4) & 0xf];
+                output[chars++] = "0123456789abcdef"[(c      ) & 0xf];
+                c = 0xdc00 | (v & 0x3ff);
+                output[chars++] = '\\';
+            }
+#endif
+            output[chars++] = 'u';
+            output[chars++] = "0123456789abcdef"[(c >> 12) & 0xf];
+            output[chars++] = "0123456789abcdef"[(c >>  8) & 0xf];
+            output[chars++] = "0123456789abcdef"[(c >>  4) & 0xf];
+            output[chars++] = "0123456789abcdef"[(c      ) & 0xf];
+    }
+    return chars;
+}
+
+static PyObject *
+ascii_escape_unicode(PyObject *pystr)
+{
+    /* Take a PyUnicode pystr and return a new ASCII-only escaped PyString */
+    Py_ssize_t i;
+    Py_ssize_t input_chars;
+    Py_ssize_t output_size;
+    Py_ssize_t max_output_size;
+    Py_ssize_t chars;
+    PyObject *rval;
+    char *output;
+    Py_UNICODE *input_unicode;
+
+    input_chars = PyUnicode_GET_SIZE(pystr);
+    input_unicode = PyUnicode_AS_UNICODE(pystr);
+
+    /* One char input can be up to 6 chars output, estimate 4 of these */
+    output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
+    max_output_size = 2 + (input_chars * MAX_EXPANSION);
+    rval = PyString_FromStringAndSize(NULL, output_size);
+    if (rval == NULL) {
+        return NULL;
+    }
+    output = PyString_AS_STRING(rval);
+    chars = 0;
+    output[chars++] = '"';
+    for (i = 0; i < input_chars; i++) {
+        Py_UNICODE c = input_unicode[i];
+        if (S_CHAR(c)) {
+            output[chars++] = (char)c;
+        }
+        else {
+            chars = ascii_escape_char(c, output, chars);
+        }
+        if (output_size - chars < (1 + MAX_EXPANSION)) {
+            /* There's more than four, so let's resize by a lot */
+            Py_ssize_t new_output_size = output_size * 2;
+            /* This is an upper bound */
+            if (new_output_size > max_output_size) {
+                new_output_size = max_output_size;
+            }
+            /* Make sure that the output size changed before resizing */
+            if (new_output_size != output_size) {
+                output_size = new_output_size;
+                if (_PyString_Resize(&rval, output_size) == -1) {
+                    return NULL;
+                }
+                output = PyString_AS_STRING(rval);
+            }
+        }
+    }
+    output[chars++] = '"';
+    if (_PyString_Resize(&rval, chars) == -1) {
+        return NULL;
+    }
+    return rval;
+}
+
+static PyObject *
+ascii_escape_str(PyObject *pystr)
+{
+    /* Take a PyString pystr and return a new ASCII-only escaped PyString */
+    Py_ssize_t i;
+    Py_ssize_t input_chars;
+    Py_ssize_t output_size;
+    Py_ssize_t chars;
+    PyObject *rval;
+    char *output;
+    char *input_str;
+
+    input_chars = PyString_GET_SIZE(pystr);
+    input_str = PyString_AS_STRING(pystr);
+
+    /* Fast path for a string that's already ASCII */
+    for (i = 0; i < input_chars; i++) {
+        Py_UNICODE c = (Py_UNICODE)(unsigned char)input_str[i];
+        if (!S_CHAR(c)) {
+            /* If we have to escape something, scan the string for unicode */
+            Py_ssize_t j;
+            for (j = i; j < input_chars; j++) {
+                c = (Py_UNICODE)(unsigned char)input_str[j];
+                if (c > 0x7f) {
+                    /* We hit a non-ASCII character, bail to unicode mode */
+                    PyObject *uni;
+                    uni = PyUnicode_DecodeUTF8(input_str, input_chars, "strict");
+                    if (uni == NULL) {
+                        return NULL;
+                    }
+                    rval = ascii_escape_unicode(uni);
+                    Py_DECREF(uni);
+                    return rval;
+                }
+            }
+            break;
+        }
+    }
+
+    if (i == input_chars) {
+        /* Input is already ASCII */
+        output_size = 2 + input_chars;
+    }
+    else {
+        /* One char input can be up to 6 chars output, estimate 4 of these */
+        output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
+    }
+    rval = PyString_FromStringAndSize(NULL, output_size);
+    if (rval == NULL) {
+        return NULL;
+    }
+    output = PyString_AS_STRING(rval);
+    output[0] = '"';
+
+    /* We know that everything up to i is ASCII already */
+    chars = i + 1;
+    memcpy(&output[1], input_str, i);
+
+    for (; i < input_chars; i++) {
+        Py_UNICODE c = (Py_UNICODE)(unsigned char)input_str[i];
+        if (S_CHAR(c)) {
+            output[chars++] = (char)c;
+        }
+        else {
+            chars = ascii_escape_char(c, output, chars);
+        }
+        /* An ASCII char can't possibly expand to a surrogate! */
+        if (output_size - chars < (1 + MIN_EXPANSION)) {
+            /* There's more than four, so let's resize by a lot */
+            output_size *= 2;
+            if (output_size > 2 + (input_chars * MIN_EXPANSION)) {
+                output_size = 2 + (input_chars * MIN_EXPANSION);
+            }
+            if (_PyString_Resize(&rval, output_size) == -1) {
+                return NULL;
+            }
+            output = PyString_AS_STRING(rval);
+        }
+    }
+    output[chars++] = '"';
+    if (_PyString_Resize(&rval, chars) == -1) {
+        return NULL;
+    }
+    return rval;
+}
+
+static void
+raise_errmsg(char *msg, PyObject *s, Py_ssize_t end)
+{
+    /* Use the Python function simplejson.decoder.errmsg to raise a nice
+    looking ValueError exception */
+    static PyObject *JSONDecodeError = NULL;
+    PyObject *exc;
+    if (JSONDecodeError == NULL) {
+        PyObject *decoder = PyImport_ImportModule("simplejson.decoder");
+        if (decoder == NULL)
+            return;
+        JSONDecodeError = PyObject_GetAttrString(decoder, "JSONDecodeError");
+        Py_DECREF(decoder);
+        if (JSONDecodeError == NULL)
+            return;
+    }
+    exc = PyObject_CallFunction(JSONDecodeError, "(zOO&)", msg, s, _convertPyInt_FromSsize_t, &end);
+    if (exc) {
+        PyErr_SetObject(JSONDecodeError, exc);
+        Py_DECREF(exc);
+    }
+}
+
+static PyObject *
+join_list_unicode(PyObject *lst)
+{
+    /* return u''.join(lst) */
+    static PyObject *joinfn = NULL;
+    if (joinfn == NULL) {
+        PyObject *ustr = PyUnicode_FromUnicode(NULL, 0);
+        if (ustr == NULL)
+            return NULL;
+
+        joinfn = PyObject_GetAttrString(ustr, "join");
+        Py_DECREF(ustr);
+        if (joinfn == NULL)
+            return NULL;
+    }
+    return PyObject_CallFunctionObjArgs(joinfn, lst, NULL);
+}
+
+static PyObject *
+join_list_string(PyObject *lst)
+{
+    /* return ''.join(lst) */
+    static PyObject *joinfn = NULL;
+    if (joinfn == NULL) {
+        PyObject *ustr = PyString_FromStringAndSize(NULL, 0);
+        if (ustr == NULL)
+            return NULL;
+
+        joinfn = PyObject_GetAttrString(ustr, "join");
+        Py_DECREF(ustr);
+        if (joinfn == NULL)
+            return NULL;
+    }
+    return PyObject_CallFunctionObjArgs(joinfn, lst, NULL);
+}
+
+static PyObject *
+_build_rval_index_tuple(PyObject *rval, Py_ssize_t idx) {
+    /* return (rval, idx) tuple, stealing reference to rval */
+    PyObject *tpl;
+    PyObject *pyidx;
+    /*
+    steal a reference to rval, returns (rval, idx)
+    */
+    if (rval == NULL) {
+        return NULL;
+    }
+    pyidx = PyInt_FromSsize_t(idx);
+    if (pyidx == NULL) {
+        Py_DECREF(rval);
+        return NULL;
+    }
+    tpl = PyTuple_New(2);
+    if (tpl == NULL) {
+        Py_DECREF(pyidx);
+        Py_DECREF(rval);
+        return NULL;
+    }
+    PyTuple_SET_ITEM(tpl, 0, rval);
+    PyTuple_SET_ITEM(tpl, 1, pyidx);
+    return tpl;
+}
+
+#define APPEND_OLD_CHUNK \
+    if (chunk != NULL) { \
+        if (chunks == NULL) { \
+            chunks = PyList_New(0); \
+            if (chunks == NULL) { \
+                goto bail; \
+            } \
+        } \
+        if (PyList_Append(chunks, chunk)) { \
+            goto bail; \
+        } \
+        Py_CLEAR(chunk); \
+    }
+
+static PyObject *
+scanstring_str(PyObject *pystr, Py_ssize_t end, char *encoding, int strict, Py_ssize_t *next_end_ptr)
+{
+    /* Read the JSON string from PyString pystr.
+    end is the index of the first character after the quote.
+    encoding is the encoding of pystr (must be an ASCII superset)
+    if strict is zero then literal control characters are allowed
+    *next_end_ptr is a return-by-reference index of the character
+        after the end quote
+
+    Return value is a new PyString (if ASCII-only) or PyUnicode
+    */
+    PyObject *rval;
+    Py_ssize_t len = PyString_GET_SIZE(pystr);
+    Py_ssize_t begin = end - 1;
+    Py_ssize_t next = begin;
+    int has_unicode = 0;
+    char *buf = PyString_AS_STRING(pystr);
+    PyObject *chunks = NULL;
+    PyObject *chunk = NULL;
+
+    if (len == end) {
+        raise_errmsg("Unterminated string starting at", pystr, begin);
+    }
+    else if (end < 0 || len < end) {
+        PyErr_SetString(PyExc_ValueError, "end is out of bounds");
+        goto bail;
+    }
+    while (1) {
+        /* Find the end of the string or the next escape */
+        Py_UNICODE c = 0;
+        for (next = end; next < len; next++) {
+            c = (unsigned char)buf[next];
+            if (c == '"' || c == '\\') {
+                break;
+            }
+            else if (strict && c <= 0x1f) {
+                raise_errmsg("Invalid control character at", pystr, next);
+                goto bail;
+            }
+            else if (c > 0x7f) {
+                has_unicode = 1;
+            }
+        }
+        if (!(c == '"' || c == '\\')) {
+            raise_errmsg("Unterminated string starting at", pystr, begin);
+            goto bail;
+        }
+        /* Pick up this chunk if it's not zero length */
+        if (next != end) {
+            PyObject *strchunk;
+            APPEND_OLD_CHUNK
+            strchunk = PyString_FromStringAndSize(&buf[end], next - end);
+            if (strchunk == NULL) {
+                goto bail;
+            }
+            if (has_unicode) {
+                chunk = PyUnicode_FromEncodedObject(strchunk, encoding, NULL);
+                Py_DECREF(strchunk);
+                if (chunk == NULL) {
+                    goto bail;
+                }
+            }
+            else {
+                chunk = strchunk;
+            }
+        }
+        next++;
+        if (c == '"') {
+            end = next;
+            break;
+        }
+        if (next == len) {
+            raise_errmsg("Unterminated string starting at", pystr, begin);
+            goto bail;
+        }
+        c = buf[next];
+        if (c != 'u') {
+            /* Non-unicode backslash escapes */
+            end = next + 1;
+            switch (c) {
+                case '"': break;
+                case '\\': break;
+                case '/': break;
+                case 'b': c = '\b'; break;
+                case 'f': c = '\f'; break;
+                case 'n': c = '\n'; break;
+                case 'r': c = '\r'; break;
+                case 't': c = '\t'; break;
+                default: c = 0;
+            }
+            if (c == 0) {
+                raise_errmsg("Invalid \\escape", pystr, end - 2);
+                goto bail;
+            }
+        }
+        else {
+            c = 0;
+            next++;
+            end = next + 4;
+            if (end >= len) {
+                raise_errmsg("Invalid \\uXXXX escape", pystr, next - 1);
+                goto bail;
+            }
+            /* Decode 4 hex digits */
+            for (; next < end; next++) {
+                Py_UNICODE digit = buf[next];
+                c <<= 4;
+                switch (digit) {
+                    case '0': case '1': case '2': case '3': case '4':
+                    case '5': case '6': case '7': case '8': case '9':
+                        c |= (digit - '0'); break;
+                    case 'a': case 'b': case 'c': case 'd': case 'e':
+                    case 'f':
+                        c |= (digit - 'a' + 10); break;
+                    case 'A': case 'B': case 'C': case 'D': case 'E':
+                    case 'F':
+                        c |= (digit - 'A' + 10); break;
+                    default:
+                        raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5);
+                        goto bail;
+                }
+            }
+#ifdef Py_UNICODE_WIDE
+            /* Surrogate pair */
+            if ((c & 0xfc00) == 0xd800) {
+                Py_UNICODE c2 = 0;
+                if (end + 6 >= len) {
+                    raise_errmsg("Unpaired high surrogate", pystr, end - 5);
+                    goto bail;
+                }
+                if (buf[next++] != '\\' || buf[next++] != 'u') {
+                    raise_errmsg("Unpaired high surrogate", pystr, end - 5);
+                    goto bail;
+                }
+                end += 6;
+                /* Decode 4 hex digits */
+                for (; next < end; next++) {
+                    c2 <<= 4;
+                    Py_UNICODE digit = buf[next];
+                    switch (digit) {
+                        case '0': case '1': case '2': case '3': case '4':
+                        case '5': case '6': case '7': case '8': case '9':
+                            c2 |= (digit - '0'); break;
+                        case 'a': case 'b': case 'c': case 'd': case 'e':
+                        case 'f':
+                            c2 |= (digit - 'a' + 10); break;
+                        case 'A': case 'B': case 'C': case 'D': case 'E':
+                        case 'F':
+                            c2 |= (digit - 'A' + 10); break;
+                        default:
+                            raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5);
+                            goto bail;
+                    }
+                }
+                if ((c2 & 0xfc00) != 0xdc00) {
+                    raise_errmsg("Unpaired high surrogate", pystr, end - 5);
+                    goto bail;
+                }
+                c = 0x10000 + (((c - 0xd800) << 10) | (c2 - 0xdc00));
+            }
+            else if ((c & 0xfc00) == 0xdc00) {
+                raise_errmsg("Unpaired low surrogate", pystr, end - 5);
+                goto bail;
+            }
+#endif
+        }
+        if (c > 0x7f) {
+            has_unicode = 1;
+        }
+        APPEND_OLD_CHUNK
+        if (has_unicode) {
+            chunk = PyUnicode_FromUnicode(&c, 1);
+            if (chunk == NULL) {
+                goto bail;
+            }
+        }
+        else {
+            char c_char = Py_CHARMASK(c);
+            chunk = PyString_FromStringAndSize(&c_char, 1);
+            if (chunk == NULL) {
+                goto bail;
+            }
+        }
+    }
+
+    if (chunks == NULL) {
+        if (chunk != NULL)
+            rval = chunk;
+        else
+            rval = PyString_FromStringAndSize("", 0);
+    }
+    else {
+        APPEND_OLD_CHUNK
+        rval = join_list_string(chunks);
+        if (rval == NULL) {
+            goto bail;
+        }
+        Py_CLEAR(chunks);
+    }
+
+    *next_end_ptr = end;
+    return rval;
+bail:
+    *next_end_ptr = -1;
+    Py_XDECREF(chunk);
+    Py_XDECREF(chunks);
+    return NULL;
+}
+
+
+static PyObject *
+scanstring_unicode(PyObject *pystr, Py_ssize_t end, int strict, Py_ssize_t *next_end_ptr)
+{
+    /* Read the JSON string from PyUnicode pystr.
+    end is the index of the first character after the quote.
+    if strict is zero then literal control characters are allowed
+    *next_end_ptr is a return-by-reference index of the character
+        after the end quote
+
+    Return value is a new PyUnicode
+    */
+    PyObject *rval;
+    Py_ssize_t len = PyUnicode_GET_SIZE(pystr);
+    Py_ssize_t begin = end - 1;
+    Py_ssize_t next = begin;
+    const Py_UNICODE *buf = PyUnicode_AS_UNICODE(pystr);
+    PyObject *chunks = NULL;
+    PyObject *chunk = NULL;
+
+    if (len == end) {
+        raise_errmsg("Unterminated string starting at", pystr, begin);
+    }
+    else if (end < 0 || len < end) {
+        PyErr_SetString(PyExc_ValueError, "end is out of bounds");
+        goto bail;
+    }
+    while (1) {
+        /* Find the end of the string or the next escape */
+        Py_UNICODE c = 0;
+        for (next = end; next < len; next++) {
+            c = buf[next];
+            if (c == '"' || c == '\\') {
+                break;
+            }
+            else if (strict && c <= 0x1f) {
+                raise_errmsg("Invalid control character at", pystr, next);
+                goto bail;
+            }
+        }
+        if (!(c == '"' || c == '\\')) {
+            raise_errmsg("Unterminated string starting at", pystr, begin);
+            goto bail;
+        }
+        /* Pick up this chunk if it's not zero length */
+        if (next != end) {
+            APPEND_OLD_CHUNK
+            chunk = PyUnicode_FromUnicode(&buf[end], next - end);
+            if (chunk == NULL) {
+                goto bail;
+            }
+        }
+        next++;
+        if (c == '"') {
+            end = next;
+            break;
+        }
+        if (next == len) {
+            raise_errmsg("Unterminated string starting at", pystr, begin);
+            goto bail;
+        }
+        c = buf[next];
+        if (c != 'u') {
+            /* Non-unicode backslash escapes */
+            end = next + 1;
+            switch (c) {
+                case '"': break;
+                case '\\': break;
+                case '/': break;
+                case 'b': c = '\b'; break;
+                case 'f': c = '\f'; break;
+                case 'n': c = '\n'; break;
+                case 'r': c = '\r'; break;
+                case 't': c = '\t'; break;
+                default: c = 0;
+            }
+            if (c == 0) {
+                raise_errmsg("Invalid \\escape", pystr, end - 2);
+                goto bail;
+            }
+        }
+        else {
+            c = 0;
+            next++;
+            end = next + 4;
+            if (end >= len) {
+                raise_errmsg("Invalid \\uXXXX escape", pystr, next - 1);
+                goto bail;
+            }
+            /* Decode 4 hex digits */
+            for (; next < end; next++) {
+                Py_UNICODE digit = buf[next];
+                c <<= 4;
+                switch (digit) {
+                    case '0': case '1': case '2': case '3': case '4':
+                    case '5': case '6': case '7': case '8': case '9':
+                        c |= (digit - '0'); break;
+                    case 'a': case 'b': case 'c': case 'd': case 'e':
+                    case 'f':
+                        c |= (digit - 'a' + 10); break;
+                    case 'A': case 'B': case 'C': case 'D': case 'E':
+                    case 'F':
+                        c |= (digit - 'A' + 10); break;
+                    default:
+                        raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5);
+                        goto bail;
+                }
+            }
+#ifdef Py_UNICODE_WIDE
+            /* Surrogate pair */
+            if ((c & 0xfc00) == 0xd800) {
+                Py_UNICODE c2 = 0;
+                if (end + 6 >= len) {
+                    raise_errmsg("Unpaired high surrogate", pystr, end - 5);
+                    goto bail;
+                }
+                if (buf[next++] != '\\' || buf[next++] != 'u') {
+                    raise_errmsg("Unpaired high surrogate", pystr, end - 5);
+                    goto bail;
+                }
+                end += 6;
+                /* Decode 4 hex digits */
+                for (; next < end; next++) {
+                    c2 <<= 4;
+                    Py_UNICODE digit = buf[next];
+                    switch (digit) {
+                        case '0': case '1': case '2': case '3': case '4':
+                        case '5': case '6': case '7': case '8': case '9':
+                            c2 |= (digit - '0'); break;
+                        case 'a': case 'b': case 'c': case 'd': case 'e':
+                        case 'f':
+                            c2 |= (digit - 'a' + 10); break;
+                        case 'A': case 'B': case 'C': case 'D': case 'E':
+                        case 'F':
+                            c2 |= (digit - 'A' + 10); break;
+                        default:
+                            raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5);
+                            goto bail;
+                    }
+                }
+                if ((c2 & 0xfc00) != 0xdc00) {
+                    raise_errmsg("Unpaired high surrogate", pystr, end - 5);
+                    goto bail;
+                }
+                c = 0x10000 + (((c - 0xd800) << 10) | (c2 - 0xdc00));
+            }
+            else if ((c & 0xfc00) == 0xdc00) {
+                raise_errmsg("Unpaired low surrogate", pystr, end - 5);
+                goto bail;
+            }
+#endif
+        }
+        APPEND_OLD_CHUNK
+        chunk = PyUnicode_FromUnicode(&c, 1);
+        if (chunk == NULL) {
+            goto bail;
+        }
+    }
+
+    if (chunks == NULL) {
+        if (chunk != NULL)
+            rval = chunk;
+        else
+            rval = PyUnicode_FromUnicode(NULL, 0);
+    }
+    else {
+        APPEND_OLD_CHUNK
+        rval = join_list_unicode(chunks);
+        if (rval == NULL) {
+            goto bail;
+        }
+        Py_CLEAR(chunks);
+    }
+    *next_end_ptr = end;
+    return rval;
+bail:
+    *next_end_ptr = -1;
+    Py_XDECREF(chunk);
+    Py_XDECREF(chunks);
+    return NULL;
+}
+
+PyDoc_STRVAR(pydoc_scanstring,
+    "scanstring(basestring, end, encoding, strict=True) -> (str, end)\n"
+    "\n"
+    "Scan the string s for a JSON string. End is the index of the\n"
+    "character in s after the quote that started the JSON string.\n"
+    "Unescapes all valid JSON string escape sequences and raises ValueError\n"
+    "on attempt to decode an invalid string. If strict is False then literal\n"
+    "control characters are allowed in the string.\n"
+    "\n"
+    "Returns a tuple of the decoded string and the index of the character in s\n"
+    "after the end quote."
+);
+
+static PyObject *
+py_scanstring(PyObject* self UNUSED, PyObject *args)
+{
+    PyObject *pystr;
+    PyObject *rval;
+    Py_ssize_t end;
+    Py_ssize_t next_end = -1;
+    char *encoding = NULL;
+    int strict = 1;
+    if (!PyArg_ParseTuple(args, "OO&|zi:scanstring", &pystr, _convertPyInt_AsSsize_t, &end, &encoding, &strict)) {
+        return NULL;
+    }
+    if (encoding == NULL) {
+        encoding = DEFAULT_ENCODING;
+    }
+    if (PyString_Check(pystr)) {
+        rval = scanstring_str(pystr, end, encoding, strict, &next_end);
+    }
+    else if (PyUnicode_Check(pystr)) {
+        rval = scanstring_unicode(pystr, end, strict, &next_end);
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                     "first argument must be a string, not %.80s",
+                     Py_TYPE(pystr)->tp_name);
+        return NULL;
+    }
+    return _build_rval_index_tuple(rval, next_end);
+}
+
+PyDoc_STRVAR(pydoc_encode_basestring_ascii,
+    "encode_basestring_ascii(basestring) -> str\n"
+    "\n"
+    "Return an ASCII-only JSON representation of a Python string"
+);
+
+static PyObject *
+py_encode_basestring_ascii(PyObject* self UNUSED, PyObject *pystr)
+{
+    /* Return an ASCII-only JSON representation of a Python string */
+    /* METH_O */
+    if (PyString_Check(pystr)) {
+        return ascii_escape_str(pystr);
+    }
+    else if (PyUnicode_Check(pystr)) {
+        return ascii_escape_unicode(pystr);
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                     "first argument must be a string, not %.80s",
+                     Py_TYPE(pystr)->tp_name);
+        return NULL;
+    }
+}
+
+static void
+scanner_dealloc(PyObject *self)
+{
+    /* Deallocate scanner object */
+    scanner_clear(self);
+    Py_TYPE(self)->tp_free(self);
+}
+
+static int
+scanner_traverse(PyObject *self, visitproc visit, void *arg)
+{
+    PyScannerObject *s;
+    assert(PyScanner_Check(self));
+    s = (PyScannerObject *)self;
+    Py_VISIT(s->encoding);
+    Py_VISIT(s->strict);
+    Py_VISIT(s->object_hook);
+    Py_VISIT(s->pairs_hook);
+    Py_VISIT(s->parse_float);
+    Py_VISIT(s->parse_int);
+    Py_VISIT(s->parse_constant);
+    Py_VISIT(s->memo);
+    return 0;
+}
+
+static int
+scanner_clear(PyObject *self)
+{
+    PyScannerObject *s;
+    assert(PyScanner_Check(self));
+    s = (PyScannerObject *)self;
+    Py_CLEAR(s->encoding);
+    Py_CLEAR(s->strict);
+    Py_CLEAR(s->object_hook);
+    Py_CLEAR(s->pairs_hook);
+    Py_CLEAR(s->parse_float);
+    Py_CLEAR(s->parse_int);
+    Py_CLEAR(s->parse_constant);
+    Py_CLEAR(s->memo);
+    return 0;
+}
+
+static PyObject *
+_parse_object_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON object from PyString pystr.
+    idx is the index of the first character after the opening curly brace.
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the closing curly brace.
+
+    Returns a new PyObject (usually a dict, but object_hook or
+    object_pairs_hook can change that)
+    */
+    char *str = PyString_AS_STRING(pystr);
+    Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1;
+    PyObject *rval = NULL;
+    PyObject *pairs = NULL;
+    PyObject *item;
+    PyObject *key = NULL;
+    PyObject *val = NULL;
+    char *encoding = PyString_AS_STRING(s->encoding);
+    int strict = PyObject_IsTrue(s->strict);
+    int has_pairs_hook = (s->pairs_hook != Py_None);
+    Py_ssize_t next_idx;
+    if (has_pairs_hook) {
+        pairs = PyList_New(0);
+        if (pairs == NULL)
+            return NULL;
+    }
+    else {
+        rval = PyDict_New();
+        if (rval == NULL)
+            return NULL;
+    }
+
+    /* skip whitespace after { */
+    while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+    /* only loop if the object is non-empty */
+    if (idx <= end_idx && str[idx] != '}') {
+        while (idx <= end_idx) {
+            PyObject *memokey;
+
+            /* read key */
+            if (str[idx] != '"') {
+                raise_errmsg(
+                    "Expecting property name enclosed in double quotes",
+                    pystr, idx);
+                goto bail;
+            }
+            key = scanstring_str(pystr, idx + 1, encoding, strict, &next_idx);
+            if (key == NULL)
+                goto bail;
+            memokey = PyDict_GetItem(s->memo, key);
+            if (memokey != NULL) {
+                Py_INCREF(memokey);
+                Py_DECREF(key);
+                key = memokey;
+            }
+            else {
+                if (PyDict_SetItem(s->memo, key, key) < 0)
+                    goto bail;
+            }
+            idx = next_idx;
+
+            /* skip whitespace between key and : delimiter, read :, skip whitespace */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+            if (idx > end_idx || str[idx] != ':') {
+                raise_errmsg("Expecting ':' delimiter", pystr, idx);
+                goto bail;
+            }
+            idx++;
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+            /* read any JSON data type */
+            val = scan_once_str(s, pystr, idx, &next_idx);
+            if (val == NULL)
+                goto bail;
+
+            if (has_pairs_hook) {
+                item = PyTuple_Pack(2, key, val);
+                if (item == NULL)
+                    goto bail;
+                Py_CLEAR(key);
+                Py_CLEAR(val);
+                if (PyList_Append(pairs, item) == -1) {
+                    Py_DECREF(item);
+                    goto bail;
+                }
+                Py_DECREF(item);
+            }
+            else {
+                if (PyDict_SetItem(rval, key, val) < 0)
+                    goto bail;
+                Py_CLEAR(key);
+                Py_CLEAR(val);
+            }
+            idx = next_idx;
+
+            /* skip whitespace before } or , */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+            /* bail if the object is closed or we didn't get the , delimiter */
+            if (idx > end_idx) break;
+            if (str[idx] == '}') {
+                break;
+            }
+            else if (str[idx] != ',') {
+                raise_errmsg("Expecting ',' delimiter", pystr, idx);
+                goto bail;
+            }
+            idx++;
+
+            /* skip whitespace after , delimiter */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+        }
+    }
+    /* verify that idx < end_idx, str[idx] should be '}' */
+    if (idx > end_idx || str[idx] != '}') {
+        raise_errmsg("Expecting object", pystr, end_idx);
+        goto bail;
+    }
+
+    /* if pairs_hook is not None: rval = object_pairs_hook(pairs) */
+    if (s->pairs_hook != Py_None) {
+        val = PyObject_CallFunctionObjArgs(s->pairs_hook, pairs, NULL);
+        if (val == NULL)
+            goto bail;
+        Py_DECREF(pairs);
+        *next_idx_ptr = idx + 1;
+        return val;
+    }
+
+    /* if object_hook is not None: rval = object_hook(rval) */
+    if (s->object_hook != Py_None) {
+        val = PyObject_CallFunctionObjArgs(s->object_hook, rval, NULL);
+        if (val == NULL)
+            goto bail;
+        Py_DECREF(rval);
+        rval = val;
+        val = NULL;
+    }
+    *next_idx_ptr = idx + 1;
+    return rval;
+bail:
+    Py_XDECREF(rval);
+    Py_XDECREF(key);
+    Py_XDECREF(val);
+    Py_XDECREF(pairs);
+    return NULL;
+}
+
+static PyObject *
+_parse_object_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON object from PyUnicode pystr.
+    idx is the index of the first character after the opening curly brace.
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the closing curly brace.
+
+    Returns a new PyObject (usually a dict, but object_hook can change that)
+    */
+    Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr);
+    Py_ssize_t end_idx = PyUnicode_GET_SIZE(pystr) - 1;
+    PyObject *rval = NULL;
+    PyObject *pairs = NULL;
+    PyObject *item;
+    PyObject *key = NULL;
+    PyObject *val = NULL;
+    int strict = PyObject_IsTrue(s->strict);
+    int has_pairs_hook = (s->pairs_hook != Py_None);
+    Py_ssize_t next_idx;
+
+    if (has_pairs_hook) {
+        pairs = PyList_New(0);
+        if (pairs == NULL)
+            return NULL;
+    }
+    else {
+        rval = PyDict_New();
+        if (rval == NULL)
+            return NULL;
+    }
+
+    /* skip whitespace after { */
+    while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+    /* only loop if the object is non-empty */
+    if (idx <= end_idx && str[idx] != '}') {
+        while (idx <= end_idx) {
+            PyObject *memokey;
+
+            /* read key */
+            if (str[idx] != '"') {
+                raise_errmsg(
+                    "Expecting property name enclosed in double quotes",
+                    pystr, idx);
+                goto bail;
+            }
+            key = scanstring_unicode(pystr, idx + 1, strict, &next_idx);
+            if (key == NULL)
+                goto bail;
+            memokey = PyDict_GetItem(s->memo, key);
+            if (memokey != NULL) {
+                Py_INCREF(memokey);
+                Py_DECREF(key);
+                key = memokey;
+            }
+            else {
+                if (PyDict_SetItem(s->memo, key, key) < 0)
+                    goto bail;
+            }
+            idx = next_idx;
+
+            /* skip whitespace between key and : delimiter, read :, skip
+               whitespace */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+            if (idx > end_idx || str[idx] != ':') {
+                raise_errmsg("Expecting ':' delimiter", pystr, idx);
+                goto bail;
+            }
+            idx++;
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+            /* read any JSON term */
+            val = scan_once_unicode(s, pystr, idx, &next_idx);
+            if (val == NULL)
+                goto bail;
+
+            if (has_pairs_hook) {
+                item = PyTuple_Pack(2, key, val);
+                if (item == NULL)
+                    goto bail;
+                Py_CLEAR(key);
+                Py_CLEAR(val);
+                if (PyList_Append(pairs, item) == -1) {
+                    Py_DECREF(item);
+                    goto bail;
+                }
+                Py_DECREF(item);
+            }
+            else {
+                if (PyDict_SetItem(rval, key, val) < 0)
+                    goto bail;
+                Py_CLEAR(key);
+                Py_CLEAR(val);
+            }
+            idx = next_idx;
+
+            /* skip whitespace before } or , */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+            /* bail if the object is closed or we didn't get the ,
+               delimiter */
+            if (idx > end_idx) break;
+            if (str[idx] == '}') {
+                break;
+            }
+            else if (str[idx] != ',') {
+                raise_errmsg("Expecting ',' delimiter", pystr, idx);
+                goto bail;
+            }
+            idx++;
+
+            /* skip whitespace after , delimiter */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+        }
+    }
+
+    /* verify that idx < end_idx, str[idx] should be '}' */
+    if (idx > end_idx || str[idx] != '}') {
+        raise_errmsg("Expecting object", pystr, end_idx);
+        goto bail;
+    }
+
+    /* if pairs_hook is not None: rval = object_pairs_hook(pairs) */
+    if (s->pairs_hook != Py_None) {
+        val = PyObject_CallFunctionObjArgs(s->pairs_hook, pairs, NULL);
+        if (val == NULL)
+            goto bail;
+        Py_DECREF(pairs);
+        *next_idx_ptr = idx + 1;
+        return val;
+    }
+
+    /* if object_hook is not None: rval = object_hook(rval) */
+    if (s->object_hook != Py_None) {
+        val = PyObject_CallFunctionObjArgs(s->object_hook, rval, NULL);
+        if (val == NULL)
+            goto bail;
+        Py_DECREF(rval);
+        rval = val;
+        val = NULL;
+    }
+    *next_idx_ptr = idx + 1;
+    return rval;
+bail:
+    Py_XDECREF(rval);
+    Py_XDECREF(key);
+    Py_XDECREF(val);
+    Py_XDECREF(pairs);
+    return NULL;
+}
+
+static PyObject *
+_parse_array_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON array from PyString pystr.
+    idx is the index of the first character after the opening brace.
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the closing brace.
+
+    Returns a new PyList
+    */
+    char *str = PyString_AS_STRING(pystr);
+    Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1;
+    PyObject *val = NULL;
+    PyObject *rval = PyList_New(0);
+    Py_ssize_t next_idx;
+    if (rval == NULL)
+        return NULL;
+
+    /* skip whitespace after [ */
+    while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+    /* only loop if the array is non-empty */
+    if (idx <= end_idx && str[idx] != ']') {
+        while (idx <= end_idx) {
+
+            /* read any JSON term and de-tuplefy the (rval, idx) */
+            val = scan_once_str(s, pystr, idx, &next_idx);
+            if (val == NULL) {
+                if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+                    PyErr_Clear();
+                    raise_errmsg("Expecting object", pystr, idx);
+                }
+                goto bail;
+            }
+
+            if (PyList_Append(rval, val) == -1)
+                goto bail;
+
+            Py_CLEAR(val);
+            idx = next_idx;
+
+            /* skip whitespace between term and , */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+            /* bail if the array is closed or we didn't get the , delimiter */
+            if (idx > end_idx) break;
+            if (str[idx] == ']') {
+                break;
+            }
+            else if (str[idx] != ',') {
+                raise_errmsg("Expecting ',' delimiter", pystr, idx);
+                goto bail;
+            }
+            idx++;
+
+            /* skip whitespace after , */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+        }
+    }
+
+    /* verify that idx < end_idx, str[idx] should be ']' */
+    if (idx > end_idx || str[idx] != ']') {
+        raise_errmsg("Expecting object", pystr, end_idx);
+        goto bail;
+    }
+    *next_idx_ptr = idx + 1;
+    return rval;
+bail:
+    Py_XDECREF(val);
+    Py_DECREF(rval);
+    return NULL;
+}
+
+static PyObject *
+_parse_array_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON array from PyString pystr.
+    idx is the index of the first character after the opening brace.
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the closing brace.
+
+    Returns a new PyList
+    */
+    Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr);
+    Py_ssize_t end_idx = PyUnicode_GET_SIZE(pystr) - 1;
+    PyObject *val = NULL;
+    PyObject *rval = PyList_New(0);
+    Py_ssize_t next_idx;
+    if (rval == NULL)
+        return NULL;
+
+    /* skip whitespace after [ */
+    while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+    /* only loop if the array is non-empty */
+    if (idx <= end_idx && str[idx] != ']') {
+        while (idx <= end_idx) {
+
+            /* read any JSON term  */
+            val = scan_once_unicode(s, pystr, idx, &next_idx);
+            if (val == NULL) {
+                if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+                    PyErr_Clear();
+                    raise_errmsg("Expecting object", pystr, idx);
+                }
+                goto bail;
+            }
+
+            if (PyList_Append(rval, val) == -1)
+                goto bail;
+
+            Py_CLEAR(val);
+            idx = next_idx;
+
+            /* skip whitespace between term and , */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+
+            /* bail if the array is closed or we didn't get the , delimiter */
+            if (idx > end_idx) break;
+            if (str[idx] == ']') {
+                break;
+            }
+            else if (str[idx] != ',') {
+                raise_errmsg("Expecting ',' delimiter", pystr, idx);
+                goto bail;
+            }
+            idx++;
+
+            /* skip whitespace after , */
+            while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;
+        }
+    }
+
+    /* verify that idx < end_idx, str[idx] should be ']' */
+    if (idx > end_idx || str[idx] != ']') {
+        raise_errmsg("Expecting object", pystr, end_idx);
+        goto bail;
+    }
+    *next_idx_ptr = idx + 1;
+    return rval;
+bail:
+    Py_XDECREF(val);
+    Py_DECREF(rval);
+    return NULL;
+}
+
+static PyObject *
+_parse_constant(PyScannerObject *s, char *constant, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON constant from PyString pystr.
+    constant is the constant string that was found
+        ("NaN", "Infinity", "-Infinity").
+    idx is the index of the first character of the constant
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the constant.
+
+    Returns the result of parse_constant
+    */
+    PyObject *cstr;
+    PyObject *rval;
+    /* constant is "NaN", "Infinity", or "-Infinity" */
+    cstr = PyString_InternFromString(constant);
+    if (cstr == NULL)
+        return NULL;
+
+    /* rval = parse_constant(constant) */
+    rval = PyObject_CallFunctionObjArgs(s->parse_constant, cstr, NULL);
+    idx += PyString_GET_SIZE(cstr);
+    Py_DECREF(cstr);
+    *next_idx_ptr = idx;
+    return rval;
+}
+
+static PyObject *
+_match_number_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON number from PyString pystr.
+    idx is the index of the first character of the number
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the number.
+
+    Returns a new PyObject representation of that number:
+        PyInt, PyLong, or PyFloat.
+        May return other types if parse_int or parse_float are set
+    */
+    char *str = PyString_AS_STRING(pystr);
+    Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1;
+    Py_ssize_t idx = start;
+    int is_float = 0;
+    PyObject *rval;
+    PyObject *numstr;
+
+    /* read a sign if it's there, make sure it's not the end of the string */
+    if (str[idx] == '-') {
+        idx++;
+        if (idx > end_idx) {
+            PyErr_SetNone(PyExc_StopIteration);
+            return NULL;
+        }
+    }
+
+    /* read as many integer digits as we find as long as it doesn't start with 0 */
+    if (str[idx] >= '1' && str[idx] <= '9') {
+        idx++;
+        while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++;
+    }
+    /* if it starts with 0 we only expect one integer digit */
+    else if (str[idx] == '0') {
+        idx++;
+    }
+    /* no integer digits, error */
+    else {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    /* if the next char is '.' followed by a digit then read all float digits */
+    if (idx < end_idx && str[idx] == '.' && str[idx + 1] >= '0' && str[idx + 1] <= '9') {
+        is_float = 1;
+        idx += 2;
+        while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++;
+    }
+
+    /* if the next char is 'e' or 'E' then maybe read the exponent (or backtrack) */
+    if (idx < end_idx && (str[idx] == 'e' || str[idx] == 'E')) {
+
+        /* save the index of the 'e' or 'E' just in case we need to backtrack */
+        Py_ssize_t e_start = idx;
+        idx++;
+
+        /* read an exponent sign if present */
+        if (idx < end_idx && (str[idx] == '-' || str[idx] == '+')) idx++;
+
+        /* read all digits */
+        while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++;
+
+        /* if we got a digit, then parse as float. if not, backtrack */
+        if (str[idx - 1] >= '0' && str[idx - 1] <= '9') {
+            is_float = 1;
+        }
+        else {
+            idx = e_start;
+        }
+    }
+
+    /* copy the section we determined to be a number */
+    numstr = PyString_FromStringAndSize(&str[start], idx - start);
+    if (numstr == NULL)
+        return NULL;
+    if (is_float) {
+        /* parse as a float using a fast path if available, otherwise call user defined method */
+        if (s->parse_float != (PyObject *)&PyFloat_Type) {
+            rval = PyObject_CallFunctionObjArgs(s->parse_float, numstr, NULL);
+        }
+        else {
+            /* rval = PyFloat_FromDouble(PyOS_ascii_atof(PyString_AS_STRING(numstr))); */
+            double d = PyOS_string_to_double(PyString_AS_STRING(numstr),
+                                             NULL, NULL);
+            if (d == -1.0 && PyErr_Occurred())
+                return NULL;
+            rval = PyFloat_FromDouble(d);
+        }
+    }
+    else {
+        /* parse as an int using a fast path if available, otherwise call user defined method */
+        if (s->parse_int != (PyObject *)&PyInt_Type) {
+            rval = PyObject_CallFunctionObjArgs(s->parse_int, numstr, NULL);
+        }
+        else {
+            rval = PyInt_FromString(PyString_AS_STRING(numstr), NULL, 10);
+        }
+    }
+    Py_DECREF(numstr);
+    *next_idx_ptr = idx;
+    return rval;
+}
+
+static PyObject *
+_match_number_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssize_t *next_idx_ptr) {
+    /* Read a JSON number from PyUnicode pystr.
+    idx is the index of the first character of the number
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the number.
+
+    Returns a new PyObject representation of that number:
+        PyInt, PyLong, or PyFloat.
+        May return other types if parse_int or parse_float are set
+    */
+    Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr);
+    Py_ssize_t end_idx = PyUnicode_GET_SIZE(pystr) - 1;
+    Py_ssize_t idx = start;
+    int is_float = 0;
+    PyObject *rval;
+    PyObject *numstr;
+
+    /* read a sign if it's there, make sure it's not the end of the string */
+    if (str[idx] == '-') {
+        idx++;
+        if (idx > end_idx) {
+            PyErr_SetNone(PyExc_StopIteration);
+            return NULL;
+        }
+    }
+
+    /* read as many integer digits as we find as long as it doesn't start with 0 */
+    if (str[idx] >= '1' && str[idx] <= '9') {
+        idx++;
+        while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++;
+    }
+    /* if it starts with 0 we only expect one integer digit */
+    else if (str[idx] == '0') {
+        idx++;
+    }
+    /* no integer digits, error */
+    else {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    /* if the next char is '.' followed by a digit then read all float digits */
+    if (idx < end_idx && str[idx] == '.' && str[idx + 1] >= '0' && str[idx + 1] <= '9') {
+        is_float = 1;
+        idx += 2;
+        while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++;
+    }
+
+    /* if the next char is 'e' or 'E' then maybe read the exponent (or backtrack) */
+    if (idx < end_idx && (str[idx] == 'e' || str[idx] == 'E')) {
+        Py_ssize_t e_start = idx;
+        idx++;
+
+        /* read an exponent sign if present */
+        if (idx < end_idx && (str[idx] == '-' || str[idx] == '+')) idx++;
+
+        /* read all digits */
+        while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++;
+
+        /* if we got a digit, then parse as float. if not, backtrack */
+        if (str[idx - 1] >= '0' && str[idx - 1] <= '9') {
+            is_float = 1;
+        }
+        else {
+            idx = e_start;
+        }
+    }
+
+    /* copy the section we determined to be a number */
+    numstr = PyUnicode_FromUnicode(&str[start], idx - start);
+    if (numstr == NULL)
+        return NULL;
+    if (is_float) {
+        /* parse as a float using a fast path if available, otherwise call user defined method */
+        if (s->parse_float != (PyObject *)&PyFloat_Type) {
+            rval = PyObject_CallFunctionObjArgs(s->parse_float, numstr, NULL);
+        }
+        else {
+            rval = PyFloat_FromString(numstr, NULL);
+        }
+    }
+    else {
+        /* no fast path for unicode -> int, just call */
+        rval = PyObject_CallFunctionObjArgs(s->parse_int, numstr, NULL);
+    }
+    Py_DECREF(numstr);
+    *next_idx_ptr = idx;
+    return rval;
+}
+
+static PyObject *
+scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr)
+{
+    /* Read one JSON term (of any kind) from PyString pystr.
+    idx is the index of the first character of the term
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the number.
+
+    Returns a new PyObject representation of the term.
+    */
+    char *str = PyString_AS_STRING(pystr);
+    Py_ssize_t length = PyString_GET_SIZE(pystr);
+    PyObject *rval = NULL;
+    int fallthrough = 0;
+    if (idx >= length) {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+    if (Py_EnterRecursiveCall(" while decoding a JSON document"))
+        return NULL;
+    switch (str[idx]) {
+        case '"':
+            /* string */
+            rval = scanstring_str(pystr, idx + 1,
+                PyString_AS_STRING(s->encoding),
+                PyObject_IsTrue(s->strict),
+                next_idx_ptr);
+            break;
+        case '{':
+            /* object */
+            rval = _parse_object_str(s, pystr, idx + 1, next_idx_ptr);
+            break;
+        case '[':
+            /* array */
+            rval = _parse_array_str(s, pystr, idx + 1, next_idx_ptr);
+            break;
+        case 'n':
+            /* null */
+            if ((idx + 3 < length) && str[idx + 1] == 'u' && str[idx + 2] == 'l' && str[idx + 3] == 'l') {
+                Py_INCREF(Py_None);
+                *next_idx_ptr = idx + 4;
+                rval = Py_None;
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 't':
+            /* true */
+            if ((idx + 3 < length) && str[idx + 1] == 'r' && str[idx + 2] == 'u' && str[idx + 3] == 'e') {
+                Py_INCREF(Py_True);
+                *next_idx_ptr = idx + 4;
+                rval = Py_True;
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 'f':
+            /* false */
+            if ((idx + 4 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'l' && str[idx + 3] == 's' && str[idx + 4] == 'e') {
+                Py_INCREF(Py_False);
+                *next_idx_ptr = idx + 5;
+                rval = Py_False;
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 'N':
+            /* NaN */
+            if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') {
+                rval = _parse_constant(s, "NaN", idx, next_idx_ptr);
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 'I':
+            /* Infinity */
+            if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') {
+                rval = _parse_constant(s, "Infinity", idx, next_idx_ptr);
+            }
+            else
+                fallthrough = 1;
+            break;
+        case '-':
+            /* -Infinity */
+            if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') {
+                rval = _parse_constant(s, "-Infinity", idx, next_idx_ptr);
+            }
+            else
+                fallthrough = 1;
+            break;
+        default:
+            fallthrough = 1;
+    }
+    /* Didn't find a string, object, array, or named constant. Look for a number. */
+    if (fallthrough)
+        rval = _match_number_str(s, pystr, idx, next_idx_ptr);
+    Py_LeaveRecursiveCall();
+    return rval;
+}
+
+static PyObject *
+scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr)
+{
+    /* Read one JSON term (of any kind) from PyUnicode pystr.
+    idx is the index of the first character of the term
+    *next_idx_ptr is a return-by-reference index to the first character after
+        the number.
+
+    Returns a new PyObject representation of the term.
+    */
+    Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr);
+    Py_ssize_t length = PyUnicode_GET_SIZE(pystr);
+    PyObject *rval = NULL;
+    int fallthrough = 0;
+    if (idx >= length) {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+    if (Py_EnterRecursiveCall(" while decoding a JSON document"))
+        return NULL;
+    switch (str[idx]) {
+        case '"':
+            /* string */
+            rval = scanstring_unicode(pystr, idx + 1,
+                PyObject_IsTrue(s->strict),
+                next_idx_ptr);
+            break;
+        case '{':
+            /* object */
+            rval = _parse_object_unicode(s, pystr, idx + 1, next_idx_ptr);
+            break;
+        case '[':
+            /* array */
+            rval = _parse_array_unicode(s, pystr, idx + 1, next_idx_ptr);
+            break;
+        case 'n':
+            /* null */
+            if ((idx + 3 < length) && str[idx + 1] == 'u' && str[idx + 2] == 'l' && str[idx + 3] == 'l') {
+                Py_INCREF(Py_None);
+                *next_idx_ptr = idx + 4;
+                rval = Py_None;
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 't':
+            /* true */
+            if ((idx + 3 < length) && str[idx + 1] == 'r' && str[idx + 2] == 'u' && str[idx + 3] == 'e') {
+                Py_INCREF(Py_True);
+                *next_idx_ptr = idx + 4;
+                rval = Py_True;
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 'f':
+            /* false */
+            if ((idx + 4 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'l' && str[idx + 3] == 's' && str[idx + 4] == 'e') {
+                Py_INCREF(Py_False);
+                *next_idx_ptr = idx + 5;
+                rval = Py_False;
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 'N':
+            /* NaN */
+            if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') {
+                rval = _parse_constant(s, "NaN", idx, next_idx_ptr);
+            }
+            else
+                fallthrough = 1;
+            break;
+        case 'I':
+            /* Infinity */
+            if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') {
+                rval = _parse_constant(s, "Infinity", idx, next_idx_ptr);
+            }
+            else
+                fallthrough = 1;
+            break;
+        case '-':
+            /* -Infinity */
+            if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') {
+                rval = _parse_constant(s, "-Infinity", idx, next_idx_ptr);
+            }
+            else
+                fallthrough = 1;
+            break;
+        default:
+            fallthrough = 1;
+    }
+    /* Didn't find a string, object, array, or named constant. Look for a number. */
+    if (fallthrough)
+        rval = _match_number_unicode(s, pystr, idx, next_idx_ptr);
+    Py_LeaveRecursiveCall();
+    return rval;
+}
+
+static PyObject *
+scanner_call(PyObject *self, PyObject *args, PyObject *kwds)
+{
+    /* Python callable interface to scan_once_{str,unicode} */
+    PyObject *pystr;
+    PyObject *rval;
+    Py_ssize_t idx;
+    Py_ssize_t next_idx = -1;
+    static char *kwlist[] = {"string", "idx", NULL};
+    PyScannerObject *s;
+    assert(PyScanner_Check(self));
+    s = (PyScannerObject *)self;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&:scan_once", kwlist, &pystr, _convertPyInt_AsSsize_t, &idx))
+        return NULL;
+
+    if (PyString_Check(pystr)) {
+        rval = scan_once_str(s, pystr, idx, &next_idx);
+    }
+    else if (PyUnicode_Check(pystr)) {
+        rval = scan_once_unicode(s, pystr, idx, &next_idx);
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+                 "first argument must be a string, not %.80s",
+                 Py_TYPE(pystr)->tp_name);
+        return NULL;
+    }
+    PyDict_Clear(s->memo);
+    return _build_rval_index_tuple(rval, next_idx);
+}
+
+static PyObject *
+scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    PyScannerObject *s;
+    s = (PyScannerObject *)type->tp_alloc(type, 0);
+    if (s != NULL) {
+        s->encoding = NULL;
+        s->strict = NULL;
+        s->object_hook = NULL;
+        s->pairs_hook = NULL;
+        s->parse_float = NULL;
+        s->parse_int = NULL;
+        s->parse_constant = NULL;
+    }
+    return (PyObject *)s;
+}
+
+static int
+scanner_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+    /* Initialize Scanner object */
+    PyObject *ctx;
+    static char *kwlist[] = {"context", NULL};
+    PyScannerObject *s;
+
+    assert(PyScanner_Check(self));
+    s = (PyScannerObject *)self;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:make_scanner", kwlist, &ctx))
+        return -1;
+
+    if (s->memo == NULL) {
+        s->memo = PyDict_New();
+        if (s->memo == NULL)
+            goto bail;
+    }
+
+    /* PyString_AS_STRING is used on encoding */
+    s->encoding = PyObject_GetAttrString(ctx, "encoding");
+    if (s->encoding == NULL)
+        goto bail;
+    if (s->encoding == Py_None) {
+        Py_DECREF(Py_None);
+        s->encoding = PyString_InternFromString(DEFAULT_ENCODING);
+    }
+    else if (PyUnicode_Check(s->encoding)) {
+        PyObject *tmp = PyUnicode_AsEncodedString(s->encoding, NULL, NULL);
+        Py_DECREF(s->encoding);
+        s->encoding = tmp;
+    }
+    if (s->encoding == NULL || !PyString_Check(s->encoding))
+        goto bail;
+
+    /* All of these will fail "gracefully" so we don't need to verify them */
+    s->strict = PyObject_GetAttrString(ctx, "strict");
+    if (s->strict == NULL)
+        goto bail;
+    s->object_hook = PyObject_GetAttrString(ctx, "object_hook");
+    if (s->object_hook == NULL)
+        goto bail;
+    s->pairs_hook = PyObject_GetAttrString(ctx, "object_pairs_hook");
+    if (s->pairs_hook == NULL)
+        goto bail;
+    s->parse_float = PyObject_GetAttrString(ctx, "parse_float");
+    if (s->parse_float == NULL)
+        goto bail;
+    s->parse_int = PyObject_GetAttrString(ctx, "parse_int");
+    if (s->parse_int == NULL)
+        goto bail;
+    s->parse_constant = PyObject_GetAttrString(ctx, "parse_constant");
+    if (s->parse_constant == NULL)
+        goto bail;
+
+    return 0;
+
+bail:
+    Py_CLEAR(s->encoding);
+    Py_CLEAR(s->strict);
+    Py_CLEAR(s->object_hook);
+    Py_CLEAR(s->pairs_hook);
+    Py_CLEAR(s->parse_float);
+    Py_CLEAR(s->parse_int);
+    Py_CLEAR(s->parse_constant);
+    return -1;
+}
+
+PyDoc_STRVAR(scanner_doc, "JSON scanner object");
+
+static
+PyTypeObject PyScannerType = {
+    PyObject_HEAD_INIT(NULL)
+    0,                    /* tp_internal */
+    "simplejson._speedups.Scanner",       /* tp_name */
+    sizeof(PyScannerObject), /* tp_basicsize */
+    0,                    /* tp_itemsize */
+    scanner_dealloc, /* tp_dealloc */
+    0,                    /* tp_print */
+    0,                    /* tp_getattr */
+    0,                    /* tp_setattr */
+    0,                    /* tp_compare */
+    0,                    /* tp_repr */
+    0,                    /* tp_as_number */
+    0,                    /* tp_as_sequence */
+    0,                    /* tp_as_mapping */
+    0,                    /* tp_hash */
+    scanner_call,         /* tp_call */
+    0,                    /* tp_str */
+    0,/* PyObject_GenericGetAttr, */                    /* tp_getattro */
+    0,/* PyObject_GenericSetAttr, */                    /* tp_setattro */
+    0,                    /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,   /* tp_flags */
+    scanner_doc,          /* tp_doc */
+    scanner_traverse,                    /* tp_traverse */
+    scanner_clear,                    /* tp_clear */
+    0,                    /* tp_richcompare */
+    0,                    /* tp_weaklistoffset */
+    0,                    /* tp_iter */
+    0,                    /* tp_iternext */
+    0,                    /* tp_methods */
+    scanner_members,                    /* tp_members */
+    0,                    /* tp_getset */
+    0,                    /* tp_base */
+    0,                    /* tp_dict */
+    0,                    /* tp_descr_get */
+    0,                    /* tp_descr_set */
+    0,                    /* tp_dictoffset */
+    scanner_init,                    /* tp_init */
+    0,/* PyType_GenericAlloc, */        /* tp_alloc */
+    scanner_new,          /* tp_new */
+    0,/* PyObject_GC_Del, */              /* tp_free */
+};
+
+static PyObject *
+encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    PyEncoderObject *s;
+    s = (PyEncoderObject *)type->tp_alloc(type, 0);
+    if (s != NULL) {
+        s->markers = NULL;
+        s->defaultfn = NULL;
+        s->encoder = NULL;
+        s->indent = NULL;
+        s->key_separator = NULL;
+        s->item_separator = NULL;
+        s->sort_keys = NULL;
+        s->skipkeys = NULL;
+        s->key_memo = NULL;
+        s->item_sort_key = NULL;
+        s->Decimal = NULL;
+    }
+    return (PyObject *)s;
+}
+
+static int
+encoder_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+    /* initialize Encoder object */
+    static char *kwlist[] = {"markers", "default", "encoder", "indent", "key_separator", "item_separator", "sort_keys", "skipkeys", "allow_nan", "key_memo", "use_decimal", "namedtuple_as_object", "tuple_as_array", "bigint_as_string", "item_sort_key", "Decimal", NULL};
+
+    PyEncoderObject *s;
+    PyObject *markers, *defaultfn, *encoder, *indent, *key_separator;
+    PyObject *item_separator, *sort_keys, *skipkeys, *allow_nan, *key_memo;
+    PyObject *use_decimal, *namedtuple_as_object, *tuple_as_array;
+    PyObject *bigint_as_string, *item_sort_key, *Decimal;
+
+    assert(PyEncoder_Check(self));
+    s = (PyEncoderObject *)self;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOOOOOOOOOOOOOO:make_encoder", kwlist,
+        &markers, &defaultfn, &encoder, &indent, &key_separator, &item_separator,
+        &sort_keys, &skipkeys, &allow_nan, &key_memo, &use_decimal,
+        &namedtuple_as_object, &tuple_as_array, &bigint_as_string,
+        &item_sort_key, &Decimal))
+        return -1;
+
+    s->markers = markers;
+    s->defaultfn = defaultfn;
+    s->encoder = encoder;
+    s->indent = indent;
+    s->key_separator = key_separator;
+    s->item_separator = item_separator;
+    s->sort_keys = sort_keys;
+    s->skipkeys = skipkeys;
+    s->key_memo = key_memo;
+    s->fast_encode = (PyCFunction_Check(s->encoder) && PyCFunction_GetFunction(s->encoder) == (PyCFunction)py_encode_basestring_ascii);
+    s->allow_nan = PyObject_IsTrue(allow_nan);
+    s->use_decimal = PyObject_IsTrue(use_decimal);
+    s->namedtuple_as_object = PyObject_IsTrue(namedtuple_as_object);
+    s->tuple_as_array = PyObject_IsTrue(tuple_as_array);
+    s->bigint_as_string = PyObject_IsTrue(bigint_as_string);
+    s->item_sort_key = item_sort_key;
+    s->Decimal = Decimal;
+
+    Py_INCREF(s->markers);
+    Py_INCREF(s->defaultfn);
+    Py_INCREF(s->encoder);
+    Py_INCREF(s->indent);
+    Py_INCREF(s->key_separator);
+    Py_INCREF(s->item_separator);
+    Py_INCREF(s->sort_keys);
+    Py_INCREF(s->skipkeys);
+    Py_INCREF(s->key_memo);
+    Py_INCREF(s->item_sort_key);
+    Py_INCREF(s->Decimal);
+    return 0;
+}
+
+static PyObject *
+encoder_call(PyObject *self, PyObject *args, PyObject *kwds)
+{
+    /* Python callable interface to encode_listencode_obj */
+    static char *kwlist[] = {"obj", "_current_indent_level", NULL};
+    PyObject *obj;
+    PyObject *rval;
+    Py_ssize_t indent_level;
+    PyEncoderObject *s;
+    assert(PyEncoder_Check(self));
+    s = (PyEncoderObject *)self;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&:_iterencode", kwlist,
+        &obj, _convertPyInt_AsSsize_t, &indent_level))
+        return NULL;
+    rval = PyList_New(0);
+    if (rval == NULL)
+        return NULL;
+    if (encoder_listencode_obj(s, rval, obj, indent_level)) {
+        Py_DECREF(rval);
+        return NULL;
+    }
+    return rval;
+}
+
+static PyObject *
+_encoded_const(PyObject *obj)
+{
+    /* Return the JSON string representation of None, True, False */
+    if (obj == Py_None) {
+        static PyObject *s_null = NULL;
+        if (s_null == NULL) {
+            s_null = PyString_InternFromString("null");
+        }
+        Py_INCREF(s_null);
+        return s_null;
+    }
+    else if (obj == Py_True) {
+        static PyObject *s_true = NULL;
+        if (s_true == NULL) {
+            s_true = PyString_InternFromString("true");
+        }
+        Py_INCREF(s_true);
+        return s_true;
+    }
+    else if (obj == Py_False) {
+        static PyObject *s_false = NULL;
+        if (s_false == NULL) {
+            s_false = PyString_InternFromString("false");
+        }
+        Py_INCREF(s_false);
+        return s_false;
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError, "not a const");
+        return NULL;
+    }
+}
+
+static PyObject *
+encoder_encode_float(PyEncoderObject *s, PyObject *obj)
+{
+    /* Return the JSON representation of a PyFloat */
+    double i = PyFloat_AS_DOUBLE(obj);
+    if (!Py_IS_FINITE(i)) {
+        if (!s->allow_nan) {
+            PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant");
+            return NULL;
+        }
+        if (i > 0) {
+            return PyString_FromString("Infinity");
+        }
+        else if (i < 0) {
+            return PyString_FromString("-Infinity");
+        }
+        else {
+            return PyString_FromString("NaN");
+        }
+    }
+    /* Use a better float format here? */
+    return PyObject_Repr(obj);
+}
+
+static PyObject *
+encoder_encode_string(PyEncoderObject *s, PyObject *obj)
+{
+    /* Return the JSON representation of a string */
+    if (s->fast_encode)
+        return py_encode_basestring_ascii(NULL, obj);
+    else
+        return PyObject_CallFunctionObjArgs(s->encoder, obj, NULL);
+}
+
+static int
+_steal_list_append(PyObject *lst, PyObject *stolen)
+{
+    /* Append stolen and then decrement its reference count */
+    int rval = PyList_Append(lst, stolen);
+    Py_DECREF(stolen);
+    return rval;
+}
+
+static int
+encoder_listencode_obj(PyEncoderObject *s, PyObject *rval, PyObject *obj, Py_ssize_t indent_level)
+{
+    /* Encode Python object obj to a JSON term, rval is a PyList */
+    int rv = -1;
+    if (Py_EnterRecursiveCall(" while encoding a JSON document"))
+        return rv;
+    do {
+        if (obj == Py_None || obj == Py_True || obj == Py_False) {
+            PyObject *cstr = _encoded_const(obj);
+            if (cstr != NULL)
+                rv = _steal_list_append(rval, cstr);
+        }
+        else if (PyString_Check(obj) || PyUnicode_Check(obj))
+        {
+            PyObject *encoded = encoder_encode_string(s, obj);
+            if (encoded != NULL)
+                rv = _steal_list_append(rval, encoded);
+        }
+        else if (PyInt_Check(obj) || PyLong_Check(obj)) {
+            PyObject *encoded = PyObject_Str(obj);
+            if (encoded != NULL) {
+                if (s->bigint_as_string) {
+                    encoded = maybe_quote_bigint(encoded, obj);
+                    if (encoded == NULL)
+                        break;
+                }
+                rv = _steal_list_append(rval, encoded);
+            }
+        }
+        else if (PyFloat_Check(obj)) {
+            PyObject *encoded = encoder_encode_float(s, obj);
+            if (encoded != NULL)
+                rv = _steal_list_append(rval, encoded);
+        }
+        else if (s->namedtuple_as_object && _is_namedtuple(obj)) {
+            PyObject *newobj = PyObject_CallMethod(obj, "_asdict", NULL);
+            if (newobj != NULL) {
+                rv = encoder_listencode_dict(s, rval, newobj, indent_level);
+                Py_DECREF(newobj);
+            }
+        }
+        else if (PyList_Check(obj) || (s->tuple_as_array && PyTuple_Check(obj))) {
+            rv = encoder_listencode_list(s, rval, obj, indent_level);
+        }
+        else if (PyDict_Check(obj)) {
+            rv = encoder_listencode_dict(s, rval, obj, indent_level);
+        }
+        else if (s->use_decimal && PyObject_TypeCheck(obj, s->Decimal)) {
+            PyObject *encoded = PyObject_Str(obj);
+            if (encoded != NULL)
+                rv = _steal_list_append(rval, encoded);
+        }
+        else {
+            PyObject *ident = NULL;
+            PyObject *newobj;
+            if (s->markers != Py_None) {
+                int has_key;
+                ident = PyLong_FromVoidPtr(obj);
+                if (ident == NULL)
+                    break;
+                has_key = PyDict_Contains(s->markers, ident);
+                if (has_key) {
+                    if (has_key != -1)
+                        PyErr_SetString(PyExc_ValueError, "Circular reference detected");
+                    Py_DECREF(ident);
+                    break;
+                }
+                if (PyDict_SetItem(s->markers, ident, obj)) {
+                    Py_DECREF(ident);
+                    break;
+                }
+            }
+            newobj = PyObject_CallFunctionObjArgs(s->defaultfn, obj, NULL);
+            if (newobj == NULL) {
+                Py_XDECREF(ident);
+                break;
+            }
+            rv = encoder_listencode_obj(s, rval, newobj, indent_level);
+            Py_DECREF(newobj);
+            if (rv) {
+                Py_XDECREF(ident);
+                rv = -1;
+            }
+            else if (ident != NULL) {
+                if (PyDict_DelItem(s->markers, ident)) {
+                    Py_XDECREF(ident);
+                    rv = -1;
+                }
+                Py_XDECREF(ident);
+            }
+        }
+    } while (0);
+    Py_LeaveRecursiveCall();
+    return rv;
+}
+
+static int
+encoder_listencode_dict(PyEncoderObject *s, PyObject *rval, PyObject *dct, Py_ssize_t indent_level)
+{
+    /* Encode Python dict dct a JSON term, rval is a PyList */
+    static PyObject *open_dict = NULL;
+    static PyObject *close_dict = NULL;
+    static PyObject *empty_dict = NULL;
+    static PyObject *iteritems = NULL;
+    PyObject *kstr = NULL;
+    PyObject *ident = NULL;
+    PyObject *iter = NULL;
+    PyObject *item = NULL;
+    PyObject *items = NULL;
+    PyObject *encoded = NULL;
+    int skipkeys;
+    Py_ssize_t idx;
+
+    if (open_dict == NULL || close_dict == NULL || empty_dict == NULL || iteritems == NULL) {
+        open_dict = PyString_InternFromString("{");
+        close_dict = PyString_InternFromString("}");
+        empty_dict = PyString_InternFromString("{}");
+        iteritems = PyString_InternFromString("iteritems");
+        if (open_dict == NULL || close_dict == NULL || empty_dict == NULL || iteritems == NULL)
+            return -1;
+    }
+    if (PyDict_Size(dct) == 0)
+        return PyList_Append(rval, empty_dict);
+
+    if (s->markers != Py_None) {
+        int has_key;
+        ident = PyLong_FromVoidPtr(dct);
+        if (ident == NULL)
+            goto bail;
+        has_key = PyDict_Contains(s->markers, ident);
+        if (has_key) {
+            if (has_key != -1)
+                PyErr_SetString(PyExc_ValueError, "Circular reference detected");
+            goto bail;
+        }
+        if (PyDict_SetItem(s->markers, ident, dct)) {
+            goto bail;
+        }
+    }
+
+    if (PyList_Append(rval, open_dict))
+        goto bail;
+
+    if (s->indent != Py_None) {
+        /* TODO: DOES NOT RUN */
+        indent_level += 1;
+        /*
+            newline_indent = '\n' + (_indent * _current_indent_level)
+            separator = _item_separator + newline_indent
+            buf += newline_indent
+        */
+    }
+
+    if (PyCallable_Check(s->item_sort_key)) {
+        if (PyDict_CheckExact(dct))
+            items = PyDict_Items(dct);
+        else
+            items = PyMapping_Items(dct);
+        PyObject_CallMethod(items, "sort", "OO", Py_None, s->item_sort_key);
+    }
+    else if (PyObject_IsTrue(s->sort_keys)) {
+        /* First sort the keys then replace them with (key, value) tuples. */
+        Py_ssize_t i, nitems;
+        if (PyDict_CheckExact(dct))
+            items = PyDict_Keys(dct);
+        else
+            items = PyMapping_Keys(dct);
+        if (items == NULL)
+            goto bail;
+        if (!PyList_Check(items)) {
+            PyErr_SetString(PyExc_ValueError, "keys must return list");
+            goto bail;
+        }
+        if (PyList_Sort(items) < 0)
+            goto bail;
+        nitems = PyList_GET_SIZE(items);
+        for (i = 0; i < nitems; i++) {
+            PyObject *key, *value;
+            key = PyList_GET_ITEM(items, i);
+            value = PyDict_GetItem(dct, key);
+            item = PyTuple_Pack(2, key, value);
+            if (item == NULL)
+                goto bail;
+            PyList_SET_ITEM(items, i, item);
+            Py_DECREF(key);
+        }
+    }
+    else {
+        if (PyDict_CheckExact(dct))
+            items = PyDict_Items(dct);
+        else
+            items = PyMapping_Items(dct);
+    }
+    if (items == NULL)
+        goto bail;
+    iter = PyObject_GetIter(items);
+    Py_DECREF(items);
+    if (iter == NULL)
+        goto bail;
+
+    skipkeys = PyObject_IsTrue(s->skipkeys);
+    idx = 0;
+    while ((item = PyIter_Next(iter))) {
+        PyObject *encoded, *key, *value;
+        if (!PyTuple_Check(item) || Py_SIZE(item) != 2) {
+            PyErr_SetString(PyExc_ValueError, "items must return 2-tuples");
+            goto bail;
+        }
+        key = PyTuple_GET_ITEM(item, 0);
+        if (key == NULL)
+            goto bail;
+        value = PyTuple_GET_ITEM(item, 1);
+        if (value == NULL)
+            goto bail;
+
+        encoded = PyDict_GetItem(s->key_memo, key);
+        if (encoded != NULL) {
+            Py_INCREF(encoded);
+        }
+        else if (PyString_Check(key) || PyUnicode_Check(key)) {
+            Py_INCREF(key);
+            kstr = key;
+        }
+        else if (PyFloat_Check(key)) {
+            kstr = encoder_encode_float(s, key);
+            if (kstr == NULL)
+                goto bail;
+        }
+        else if (key == Py_True || key == Py_False || key == Py_None) {
+            /* This must come before the PyInt_Check because
+               True and False are also 1 and 0.*/
+            kstr = _encoded_const(key);
+            if (kstr == NULL)
+                goto bail;
+        }
+        else if (PyInt_Check(key) || PyLong_Check(key)) {
+            kstr = PyObject_Str(key);
+            if (kstr == NULL)
+                goto bail;
+        }
+        else if (skipkeys) {
+            Py_DECREF(item);
+            continue;
+        }
+        else {
+            /* TODO: include repr of key */
+            PyErr_SetString(PyExc_TypeError, "keys must be a string");
+            goto bail;
+        }
+
+        if (idx) {
+            if (PyList_Append(rval, s->item_separator))
+                goto bail;
+        }
+
+        if (encoded == NULL) {
+            encoded = encoder_encode_string(s, kstr);
+            Py_CLEAR(kstr);
+            if (encoded == NULL)
+                goto bail;
+            if (PyDict_SetItem(s->key_memo, key, encoded))
+                goto bail;
+        }
+        if (PyList_Append(rval, encoded)) {
+            goto bail;
+        }
+        Py_CLEAR(encoded);
+        if (PyList_Append(rval, s->key_separator))
+            goto bail;
+        if (encoder_listencode_obj(s, rval, value, indent_level))
+            goto bail;
+        Py_CLEAR(item);
+        idx += 1;
+    }
+    Py_CLEAR(iter);
+    if (PyErr_Occurred())
+        goto bail;
+    if (ident != NULL) {
+        if (PyDict_DelItem(s->markers, ident))
+            goto bail;
+        Py_CLEAR(ident);
+    }
+    if (s->indent != Py_None) {
+        /* TODO: DOES NOT RUN */
+        indent_level -= 1;
+        /*
+            yield '\n' + (_indent * _current_indent_level)
+        */
+    }
+    if (PyList_Append(rval, close_dict))
+        goto bail;
+    return 0;
+
+bail:
+    Py_XDECREF(encoded);
+    Py_XDECREF(items);
+    Py_XDECREF(iter);
+    Py_XDECREF(kstr);
+    Py_XDECREF(ident);
+    return -1;
+}
+
+
+static int
+encoder_listencode_list(PyEncoderObject *s, PyObject *rval, PyObject *seq, Py_ssize_t indent_level)
+{
+    /* Encode Python list seq to a JSON term, rval is a PyList */
+    static PyObject *open_array = NULL;
+    static PyObject *close_array = NULL;
+    static PyObject *empty_array = NULL;
+    PyObject *ident = NULL;
+    PyObject *iter = NULL;
+    PyObject *obj = NULL;
+    int is_true;
+    int i = 0;
+
+    if (open_array == NULL || close_array == NULL || empty_array == NULL) {
+        open_array = PyString_InternFromString("[");
+        close_array = PyString_InternFromString("]");
+        empty_array = PyString_InternFromString("[]");
+        if (open_array == NULL || close_array == NULL || empty_array == NULL)
+            return -1;
+    }
+    ident = NULL;
+    is_true = PyObject_IsTrue(seq);
+    if (is_true == -1)
+        return -1;
+    else if (is_true == 0)
+        return PyList_Append(rval, empty_array);
+
+    if (s->markers != Py_None) {
+        int has_key;
+        ident = PyLong_FromVoidPtr(seq);
+        if (ident == NULL)
+            goto bail;
+        has_key = PyDict_Contains(s->markers, ident);
+        if (has_key) {
+            if (has_key != -1)
+                PyErr_SetString(PyExc_ValueError, "Circular reference detected");
+            goto bail;
+        }
+        if (PyDict_SetItem(s->markers, ident, seq)) {
+            goto bail;
+        }
+    }
+
+    iter = PyObject_GetIter(seq);
+    if (iter == NULL)
+        goto bail;
+
+    if (PyList_Append(rval, open_array))
+        goto bail;
+    if (s->indent != Py_None) {
+        /* TODO: DOES NOT RUN */
+        indent_level += 1;
+        /*
+            newline_indent = '\n' + (_indent * _current_indent_level)
+            separator = _item_separator + newline_indent
+            buf += newline_indent
+        */
+    }
+    while ((obj = PyIter_Next(iter))) {
+        if (i) {
+            if (PyList_Append(rval, s->item_separator))
+                goto bail;
+        }
+        if (encoder_listencode_obj(s, rval, obj, indent_level))
+            goto bail;
+        i++;
+        Py_CLEAR(obj);
+    }
+    Py_CLEAR(iter);
+    if (PyErr_Occurred())
+        goto bail;
+    if (ident != NULL) {
+        if (PyDict_DelItem(s->markers, ident))
+            goto bail;
+        Py_CLEAR(ident);
+    }
+    if (s->indent != Py_None) {
+        /* TODO: DOES NOT RUN */
+        indent_level -= 1;
+        /*
+            yield '\n' + (_indent * _current_indent_level)
+        */
+    }
+    if (PyList_Append(rval, close_array))
+        goto bail;
+    return 0;
+
+bail:
+    Py_XDECREF(obj);
+    Py_XDECREF(iter);
+    Py_XDECREF(ident);
+    return -1;
+}
+
+static void
+encoder_dealloc(PyObject *self)
+{
+    /* Deallocate Encoder */
+    encoder_clear(self);
+    Py_TYPE(self)->tp_free(self);
+}
+
+static int
+encoder_traverse(PyObject *self, visitproc visit, void *arg)
+{
+    PyEncoderObject *s;
+    assert(PyEncoder_Check(self));
+    s = (PyEncoderObject *)self;
+    Py_VISIT(s->markers);
+    Py_VISIT(s->defaultfn);
+    Py_VISIT(s->encoder);
+    Py_VISIT(s->indent);
+    Py_VISIT(s->key_separator);
+    Py_VISIT(s->item_separator);
+    Py_VISIT(s->sort_keys);
+    Py_VISIT(s->skipkeys);
+    Py_VISIT(s->key_memo);
+    Py_VISIT(s->item_sort_key);
+    return 0;
+}
+
+static int
+encoder_clear(PyObject *self)
+{
+    /* Deallocate Encoder */
+    PyEncoderObject *s;
+    assert(PyEncoder_Check(self));
+    s = (PyEncoderObject *)self;
+    Py_CLEAR(s->markers);
+    Py_CLEAR(s->defaultfn);
+    Py_CLEAR(s->encoder);
+    Py_CLEAR(s->indent);
+    Py_CLEAR(s->key_separator);
+    Py_CLEAR(s->item_separator);
+    Py_CLEAR(s->sort_keys);
+    Py_CLEAR(s->skipkeys);
+    Py_CLEAR(s->key_memo);
+    Py_CLEAR(s->item_sort_key);
+    Py_CLEAR(s->Decimal);
+    return 0;
+}
+
+PyDoc_STRVAR(encoder_doc, "_iterencode(obj, _current_indent_level) -> iterable");
+
+static
+PyTypeObject PyEncoderType = {
+    PyObject_HEAD_INIT(NULL)
+    0,                    /* tp_internal */
+    "simplejson._speedups.Encoder",       /* tp_name */
+    sizeof(PyEncoderObject), /* tp_basicsize */
+    0,                    /* tp_itemsize */
+    encoder_dealloc, /* tp_dealloc */
+    0,                    /* tp_print */
+    0,                    /* tp_getattr */
+    0,                    /* tp_setattr */
+    0,                    /* tp_compare */
+    0,                    /* tp_repr */
+    0,                    /* tp_as_number */
+    0,                    /* tp_as_sequence */
+    0,                    /* tp_as_mapping */
+    0,                    /* tp_hash */
+    encoder_call,         /* tp_call */
+    0,                    /* tp_str */
+    0,                    /* tp_getattro */
+    0,                    /* tp_setattro */
+    0,                    /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,   /* tp_flags */
+    encoder_doc,          /* tp_doc */
+    encoder_traverse,     /* tp_traverse */
+    encoder_clear,        /* tp_clear */
+    0,                    /* tp_richcompare */
+    0,                    /* tp_weaklistoffset */
+    0,                    /* tp_iter */
+    0,                    /* tp_iternext */
+    0,                    /* tp_methods */
+    encoder_members,      /* tp_members */
+    0,                    /* tp_getset */
+    0,                    /* tp_base */
+    0,                    /* tp_dict */
+    0,                    /* tp_descr_get */
+    0,                    /* tp_descr_set */
+    0,                    /* tp_dictoffset */
+    encoder_init,         /* tp_init */
+    0,                    /* tp_alloc */
+    encoder_new,          /* tp_new */
+    0,                    /* tp_free */
+};
+
+static PyMethodDef speedups_methods[] = {
+    {"encode_basestring_ascii",
+        (PyCFunction)py_encode_basestring_ascii,
+        METH_O,
+        pydoc_encode_basestring_ascii},
+    {"scanstring",
+        (PyCFunction)py_scanstring,
+        METH_VARARGS,
+        pydoc_scanstring},
+    {NULL, NULL, 0, NULL}
+};
+
+PyDoc_STRVAR(module_doc,
+"simplejson speedups\n");
+
+void
+init_speedups(void)
+{
+    PyObject *m;
+    PyScannerType.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyScannerType) < 0)
+        return;
+    PyEncoderType.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyEncoderType) < 0)
+        return;
+
+
+    m = Py_InitModule3("_speedups", speedups_methods, module_doc);
+    Py_INCREF((PyObject*)&PyScannerType);
+    PyModule_AddObject(m, "make_scanner", (PyObject*)&PyScannerType);
+    Py_INCREF((PyObject*)&PyEncoderType);
+    PyModule_AddObject(m, "make_encoder", (PyObject*)&PyEncoderType);
+}
diff --git a/script/test/diffcalc (copy)/simplejson/decoder.py b/script/test/diffcalc (copy)/simplejson/decoder.py
new file mode 100644
index 0000000..1c1526c
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/decoder.py	
@@ -0,0 +1,427 @@
+"""Implementation of JSONDecoder
+"""
+import re
+import sys
+import struct
+
+from simplejson.scanner import make_scanner
+def _import_c_scanstring():
+    try:
+        from simplejson._speedups import scanstring
+        return scanstring
+    except ImportError:
+        return None
+c_scanstring = _import_c_scanstring()
+
+__all__ = ['JSONDecoder']
+
+FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
+
+def _floatconstants():
+    _BYTES = '7FF80000000000007FF0000000000000'.decode('hex')
+    # The struct module in Python 2.4 would get frexp() out of range here
+    # when an endian is specified in the format string. Fixed in Python 2.5+
+    if sys.byteorder != 'big':
+        _BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1]
+    nan, inf = struct.unpack('dd', _BYTES)
+    return nan, inf, -inf
+
+NaN, PosInf, NegInf = _floatconstants()
+
+
+class JSONDecodeError(ValueError):
+    """Subclass of ValueError with the following additional properties:
+
+    msg: The unformatted error message
+    doc: The JSON document being parsed
+    pos: The start index of doc where parsing failed
+    end: The end index of doc where parsing failed (may be None)
+    lineno: The line corresponding to pos
+    colno: The column corresponding to pos
+    endlineno: The line corresponding to end (may be None)
+    endcolno: The column corresponding to end (may be None)
+
+    """
+    def __init__(self, msg, doc, pos, end=None):
+        ValueError.__init__(self, errmsg(msg, doc, pos, end=end))
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.end = end
+        self.lineno, self.colno = linecol(doc, pos)
+        if end is not None:
+            self.endlineno, self.endcolno = linecol(doc, end)
+        else:
+            self.endlineno, self.endcolno = None, None
+
+
+def linecol(doc, pos):
+    lineno = doc.count('\n', 0, pos) + 1
+    if lineno == 1:
+        colno = pos
+    else:
+        colno = pos - doc.rindex('\n', 0, pos)
+    return lineno, colno
+
+
+def errmsg(msg, doc, pos, end=None):
+    # Note that this function is called from _speedups
+    lineno, colno = linecol(doc, pos)
+    if end is None:
+        #fmt = '{0}: line {1} column {2} (char {3})'
+        #return fmt.format(msg, lineno, colno, pos)
+        fmt = '%s: line %d column %d (char %d)'
+        return fmt % (msg, lineno, colno, pos)
+    endlineno, endcolno = linecol(doc, end)
+    #fmt = '{0}: line {1} column {2} - line {3} column {4} (char {5} - {6})'
+    #return fmt.format(msg, lineno, colno, endlineno, endcolno, pos, end)
+    fmt = '%s: line %d column %d - line %d column %d (char %d - %d)'
+    return fmt % (msg, lineno, colno, endlineno, endcolno, pos, end)
+
+
+_CONSTANTS = {
+    '-Infinity': NegInf,
+    'Infinity': PosInf,
+    'NaN': NaN,
+}
+
+STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS)
+BACKSLASH = {
+    '"': u'"', '\\': u'\\', '/': u'/',
+    'b': u'\b', 'f': u'\f', 'n': u'\n', 'r': u'\r', 't': u'\t',
+}
+
+DEFAULT_ENCODING = "utf-8"
+
+def py_scanstring(s, end, encoding=None, strict=True,
+        _b=BACKSLASH, _m=STRINGCHUNK.match):
+    """Scan the string s for a JSON string. End is the index of the
+    character in s after the quote that started the JSON string.
+    Unescapes all valid JSON string escape sequences and raises ValueError
+    on attempt to decode an invalid string. If strict is False then literal
+    control characters are allowed in the string.
+
+    Returns a tuple of the decoded string and the index of the character in s
+    after the end quote."""
+    if encoding is None:
+        encoding = DEFAULT_ENCODING
+    chunks = []
+    _append = chunks.append
+    begin = end - 1
+    while 1:
+        chunk = _m(s, end)
+        if chunk is None:
+            raise JSONDecodeError(
+                "Unterminated string starting at", s, begin)
+        end = chunk.end()
+        content, terminator = chunk.groups()
+        # Content is contains zero or more unescaped string characters
+        if content:
+            if not isinstance(content, unicode):
+                content = unicode(content, encoding)
+            _append(content)
+        # Terminator is the end of string, a literal control character,
+        # or a backslash denoting that an escape sequence follows
+        if terminator == '"':
+            break
+        elif terminator != '\\':
+            if strict:
+                msg = "Invalid control character %r at" % (terminator,)
+                #msg = "Invalid control character {0!r} at".format(terminator)
+                raise JSONDecodeError(msg, s, end)
+            else:
+                _append(terminator)
+                continue
+        try:
+            esc = s[end]
+        except IndexError:
+            raise JSONDecodeError(
+                "Unterminated string starting at", s, begin)
+        # If not a unicode escape sequence, must be in the lookup table
+        if esc != 'u':
+            try:
+                char = _b[esc]
+            except KeyError:
+                msg = "Invalid \\escape: " + repr(esc)
+                raise JSONDecodeError(msg, s, end)
+            end += 1
+        else:
+            # Unicode escape sequence
+            esc = s[end + 1:end + 5]
+            next_end = end + 5
+            if len(esc) != 4:
+                msg = "Invalid \\uXXXX escape"
+                raise JSONDecodeError(msg, s, end)
+            uni = int(esc, 16)
+            # Check for surrogate pair on UCS-4 systems
+            if 0xd800 <= uni <= 0xdbff and sys.maxunicode > 65535:
+                msg = "Invalid \\uXXXX\\uXXXX surrogate pair"
+                if not s[end + 5:end + 7] == '\\u':
+                    raise JSONDecodeError(msg, s, end)
+                esc2 = s[end + 7:end + 11]
+                if len(esc2) != 4:
+                    raise JSONDecodeError(msg, s, end)
+                uni2 = int(esc2, 16)
+                uni = 0x10000 + (((uni - 0xd800) << 10) | (uni2 - 0xdc00))
+                next_end += 6
+            char = unichr(uni)
+            end = next_end
+        # Append the unescaped character
+        _append(char)
+    return u''.join(chunks), end
+
+
+# Use speedup if available
+scanstring = c_scanstring or py_scanstring
+
+WHITESPACE = re.compile(r'[ \t\n\r]*', FLAGS)
+WHITESPACE_STR = ' \t\n\r'
+
+def JSONObject((s, end), encoding, strict, scan_once, object_hook,
+        object_pairs_hook, memo=None,
+        _w=WHITESPACE.match, _ws=WHITESPACE_STR):
+    # Backwards compatibility
+    if memo is None:
+        memo = {}
+    memo_get = memo.setdefault
+    pairs = []
+    # Use a slice to prevent IndexError from being raised, the following
+    # check will raise a more specific ValueError if the string is empty
+    nextchar = s[end:end + 1]
+    # Normally we expect nextchar == '"'
+    if nextchar != '"':
+        if nextchar in _ws:
+            end = _w(s, end).end()
+            nextchar = s[end:end + 1]
+        # Trivial empty object
+        if nextchar == '}':
+            if object_pairs_hook is not None:
+                result = object_pairs_hook(pairs)
+                return result, end + 1
+            pairs = {}
+            if object_hook is not None:
+                pairs = object_hook(pairs)
+            return pairs, end + 1
+        elif nextchar != '"':
+            raise JSONDecodeError(
+                "Expecting property name enclosed in double quotes",
+                s, end)
+    end += 1
+    while True:
+        key, end = scanstring(s, end, encoding, strict)
+        key = memo_get(key, key)
+
+        # To skip some function call overhead we optimize the fast paths where
+        # the JSON key separator is ": " or just ":".
+        if s[end:end + 1] != ':':
+            end = _w(s, end).end()
+            if s[end:end + 1] != ':':
+                raise JSONDecodeError("Expecting ':' delimiter", s, end)
+
+        end += 1
+
+        try:
+            if s[end] in _ws:
+                end += 1
+                if s[end] in _ws:
+                    end = _w(s, end + 1).end()
+        except IndexError:
+            pass
+
+        try:
+            value, end = scan_once(s, end)
+        except StopIteration:
+            raise JSONDecodeError("Expecting object", s, end)
+        pairs.append((key, value))
+
+        try:
+            nextchar = s[end]
+            if nextchar in _ws:
+                end = _w(s, end + 1).end()
+                nextchar = s[end]
+        except IndexError:
+            nextchar = ''
+        end += 1
+
+        if nextchar == '}':
+            break
+        elif nextchar != ',':
+            raise JSONDecodeError("Expecting ',' delimiter", s, end - 1)
+
+        try:
+            nextchar = s[end]
+            if nextchar in _ws:
+                end += 1
+                nextchar = s[end]
+                if nextchar in _ws:
+                    end = _w(s, end + 1).end()
+                    nextchar = s[end]
+        except IndexError:
+            nextchar = ''
+
+        end += 1
+        if nextchar != '"':
+            raise JSONDecodeError(
+                "Expecting property name enclosed in double quotes",
+                s, end - 1)
+
+    if object_pairs_hook is not None:
+        result = object_pairs_hook(pairs)
+        return result, end
+    pairs = dict(pairs)
+    if object_hook is not None:
+        pairs = object_hook(pairs)
+    return pairs, end
+
+def JSONArray((s, end), scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_STR):
+    values = []
+    nextchar = s[end:end + 1]
+    if nextchar in _ws:
+        end = _w(s, end + 1).end()
+        nextchar = s[end:end + 1]
+    # Look-ahead for trivial empty array
+    if nextchar == ']':
+        return values, end + 1
+    _append = values.append
+    while True:
+        try:
+            value, end = scan_once(s, end)
+        except StopIteration:
+            raise JSONDecodeError("Expecting object", s, end)
+        _append(value)
+        nextchar = s[end:end + 1]
+        if nextchar in _ws:
+            end = _w(s, end + 1).end()
+            nextchar = s[end:end + 1]
+        end += 1
+        if nextchar == ']':
+            break
+        elif nextchar != ',':
+            raise JSONDecodeError("Expecting ',' delimiter", s, end)
+
+        try:
+            if s[end] in _ws:
+                end += 1
+                if s[end] in _ws:
+                    end = _w(s, end + 1).end()
+        except IndexError:
+            pass
+
+    return values, end
+
+class JSONDecoder(object):
+    """Simple JSON <http://json.org> decoder
+
+    Performs the following translations in decoding by default:
+
+    +---------------+-------------------+
+    | JSON          | Python            |
+    +===============+===================+
+    | object        | dict              |
+    +---------------+-------------------+
+    | array         | list              |
+    +---------------+-------------------+
+    | string        | unicode           |
+    +---------------+-------------------+
+    | number (int)  | int, long         |
+    +---------------+-------------------+
+    | number (real) | float             |
+    +---------------+-------------------+
+    | true          | True              |
+    +---------------+-------------------+
+    | false         | False             |
+    +---------------+-------------------+
+    | null          | None              |
+    +---------------+-------------------+
+
+    It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
+    their corresponding ``float`` values, which is outside the JSON spec.
+
+    """
+
+    def __init__(self, encoding=None, object_hook=None, parse_float=None,
+            parse_int=None, parse_constant=None, strict=True,
+            object_pairs_hook=None):
+        """
+        *encoding* determines the encoding used to interpret any
+        :class:`str` objects decoded by this instance (``'utf-8'`` by
+        default).  It has no effect when decoding :class:`unicode` objects.
+
+        Note that currently only encodings that are a superset of ASCII work,
+        strings of other encodings should be passed in as :class:`unicode`.
+
+        *object_hook*, if specified, will be called with the result of every
+        JSON object decoded and its return value will be used in place of the
+        given :class:`dict`.  This can be used to provide custom
+        deserializations (e.g. to support JSON-RPC class hinting).
+
+        *object_pairs_hook* is an optional function that will be called with
+        the result of any object literal decode with an ordered list of pairs.
+        The return value of *object_pairs_hook* will be used instead of the
+        :class:`dict`.  This feature can be used to implement custom decoders
+        that rely on the order that the key and value pairs are decoded (for
+        example, :func:`collections.OrderedDict` will remember the order of
+        insertion). If *object_hook* is also defined, the *object_pairs_hook*
+        takes priority.
+
+        *parse_float*, if specified, will be called with the string of every
+        JSON float to be decoded.  By default, this is equivalent to
+        ``float(num_str)``. This can be used to use another datatype or parser
+        for JSON floats (e.g. :class:`decimal.Decimal`).
+
+        *parse_int*, if specified, will be called with the string of every
+        JSON int to be decoded.  By default, this is equivalent to
+        ``int(num_str)``.  This can be used to use another datatype or parser
+        for JSON integers (e.g. :class:`float`).
+
+        *parse_constant*, if specified, will be called with one of the
+        following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``.  This
+        can be used to raise an exception if invalid JSON numbers are
+        encountered.
+
+        *strict* controls the parser's behavior when it encounters an
+        invalid control character in a string. The default setting of
+        ``True`` means that unescaped control characters are parse errors, if
+        ``False`` then control characters will be allowed in strings.
+
+        """
+        self.encoding = encoding
+        self.object_hook = object_hook
+        self.object_pairs_hook = object_pairs_hook
+        self.parse_float = parse_float or float
+        self.parse_int = parse_int or int
+        self.parse_constant = parse_constant or _CONSTANTS.__getitem__
+        self.strict = strict
+        self.parse_object = JSONObject
+        self.parse_array = JSONArray
+        self.parse_string = scanstring
+        self.memo = {}
+        self.scan_once = make_scanner(self)
+
+    def decode(self, s, _w=WHITESPACE.match):
+        """Return the Python representation of ``s`` (a ``str`` or ``unicode``
+        instance containing a JSON document)
+
+        """
+        obj, end = self.raw_decode(s)
+        end = _w(s, end).end()
+        if end != len(s):
+            raise JSONDecodeError("Extra data", s, end, len(s))
+        return obj
+
+    def raw_decode(self, s, idx=0, _w=WHITESPACE.match):
+        """Decode a JSON document from ``s`` (a ``str`` or ``unicode``
+        beginning with a JSON document) and return a 2-tuple of the Python
+        representation and the index in ``s`` where the document ended.
+        Optionally, ``idx`` can be used to specify an offset in ``s`` where
+        the JSON document begins.
+
+        This can be used to decode a JSON document from a string that may
+        have extraneous data at the end.
+
+        """
+        try:
+            obj, end = self.scan_once(s, idx=_w(s, idx).end())
+        except StopIteration:
+            raise JSONDecodeError("No JSON object could be decoded", s, idx)
+        return obj, end
diff --git a/script/test/diffcalc (copy)/simplejson/encoder.py b/script/test/diffcalc (copy)/simplejson/encoder.py
new file mode 100644
index 0000000..6b4a6a4
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/encoder.py	
@@ -0,0 +1,567 @@
+"""Implementation of JSONEncoder
+"""
+import re
+from decimal import Decimal
+
+def _import_speedups():
+    try:
+        from simplejson import _speedups
+        return _speedups.encode_basestring_ascii, _speedups.make_encoder
+    except ImportError:
+        return None, None
+c_encode_basestring_ascii, c_make_encoder = _import_speedups()
+
+from simplejson.decoder import PosInf
+
+ESCAPE = re.compile(ur'[\x00-\x1f\\"\b\f\n\r\t\u2028\u2029]')
+ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
+HAS_UTF8 = re.compile(r'[\x80-\xff]')
+ESCAPE_DCT = {
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    u'\u2028': '\\u2028',
+    u'\u2029': '\\u2029',
+}
+for i in range(0x20):
+    #ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
+    ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+
+FLOAT_REPR = repr
+
+def encode_basestring(s):
+    """Return a JSON representation of a Python string
+
+    """
+    if isinstance(s, str) and HAS_UTF8.search(s) is not None:
+        s = s.decode('utf-8')
+    def replace(match):
+        return ESCAPE_DCT[match.group(0)]
+    return u'"' + ESCAPE.sub(replace, s) + u'"'
+
+
+def py_encode_basestring_ascii(s):
+    """Return an ASCII-only JSON representation of a Python string
+
+    """
+    if isinstance(s, str) and HAS_UTF8.search(s) is not None:
+        s = s.decode('utf-8')
+    def replace(match):
+        s = match.group(0)
+        try:
+            return ESCAPE_DCT[s]
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                #return '\\u{0:04x}'.format(n)
+                return '\\u%04x' % (n,)
+            else:
+                # surrogate pair
+                n -= 0x10000
+                s1 = 0xd800 | ((n >> 10) & 0x3ff)
+                s2 = 0xdc00 | (n & 0x3ff)
+                #return '\\u{0:04x}\\u{1:04x}'.format(s1, s2)
+                return '\\u%04x\\u%04x' % (s1, s2)
+    return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"'
+
+
+encode_basestring_ascii = (
+    c_encode_basestring_ascii or py_encode_basestring_ascii)
+
+class JSONEncoder(object):
+    """Extensible JSON <http://json.org> encoder for Python data structures.
+
+    Supports the following objects and types by default:
+
+    +-------------------+---------------+
+    | Python            | JSON          |
+    +===================+===============+
+    | dict, namedtuple  | object        |
+    +-------------------+---------------+
+    | list, tuple       | array         |
+    +-------------------+---------------+
+    | str, unicode      | string        |
+    +-------------------+---------------+
+    | int, long, float  | number        |
+    +-------------------+---------------+
+    | True              | true          |
+    +-------------------+---------------+
+    | False             | false         |
+    +-------------------+---------------+
+    | None              | null          |
+    +-------------------+---------------+
+
+    To extend this to recognize other objects, subclass and implement a
+    ``.default()`` method with another method that returns a serializable
+    object for ``o`` if possible, otherwise it should call the superclass
+    implementation (to raise ``TypeError``).
+
+    """
+    item_separator = ', '
+    key_separator = ': '
+    def __init__(self, skipkeys=False, ensure_ascii=True,
+            check_circular=True, allow_nan=True, sort_keys=False,
+            indent=None, separators=None, encoding='utf-8', default=None,
+            use_decimal=True, namedtuple_as_object=True,
+            tuple_as_array=True, bigint_as_string=False,
+            item_sort_key=None):
+        """Constructor for JSONEncoder, with sensible defaults.
+
+        If skipkeys is false, then it is a TypeError to attempt
+        encoding of keys that are not str, int, long, float or None.  If
+        skipkeys is True, such items are simply skipped.
+
+        If ensure_ascii is true, the output is guaranteed to be str
+        objects with all incoming unicode characters escaped.  If
+        ensure_ascii is false, the output will be unicode object.
+
+        If check_circular is true, then lists, dicts, and custom encoded
+        objects will be checked for circular references during encoding to
+        prevent an infinite recursion (which would cause an OverflowError).
+        Otherwise, no such check takes place.
+
+        If allow_nan is true, then NaN, Infinity, and -Infinity will be
+        encoded as such.  This behavior is not JSON specification compliant,
+        but is consistent with most JavaScript based encoders and decoders.
+        Otherwise, it will be a ValueError to encode such floats.
+
+        If sort_keys is true, then the output of dictionaries will be
+        sorted by key; this is useful for regression tests to ensure
+        that JSON serializations can be compared on a day-to-day basis.
+
+        If indent is a string, then JSON array elements and object members
+        will be pretty-printed with a newline followed by that string repeated
+        for each level of nesting. ``None`` (the default) selects the most compact
+        representation without any newlines. For backwards compatibility with
+        versions of simplejson earlier than 2.1.0, an integer is also accepted
+        and is converted to a string with that many spaces.
+
+        If specified, separators should be a (item_separator, key_separator)
+        tuple.  The default is (', ', ': ').  To get the most compact JSON
+        representation you should specify (',', ':') to eliminate whitespace.
+
+        If specified, default is a function that gets called for objects
+        that can't otherwise be serialized.  It should return a JSON encodable
+        version of the object or raise a ``TypeError``.
+
+        If encoding is not None, then all input strings will be
+        transformed into unicode using that encoding prior to JSON-encoding.
+        The default is UTF-8.
+
+        If use_decimal is true (not the default), ``decimal.Decimal`` will
+        be supported directly by the encoder. For the inverse, decode JSON
+        with ``parse_float=decimal.Decimal``.
+
+        If namedtuple_as_object is true (the default), objects with
+        ``_asdict()`` methods will be encoded as JSON objects.
+
+        If tuple_as_array is true (the default), tuple (and subclasses) will
+        be encoded as JSON arrays.
+
+        If bigint_as_string is true (not the default), ints 2**53 and higher
+        or lower than -2**53 will be encoded as strings. This is to avoid the
+        rounding that happens in Javascript otherwise.
+
+        If specified, item_sort_key is a callable used to sort the items in
+        each dictionary. This is useful if you want to sort items other than
+        in alphabetical order by key.
+        """
+
+        self.skipkeys = skipkeys
+        self.ensure_ascii = ensure_ascii
+        self.check_circular = check_circular
+        self.allow_nan = allow_nan
+        self.sort_keys = sort_keys
+        self.use_decimal = use_decimal
+        self.namedtuple_as_object = namedtuple_as_object
+        self.tuple_as_array = tuple_as_array
+        self.bigint_as_string = bigint_as_string
+        self.item_sort_key = item_sort_key
+        if indent is not None and not isinstance(indent, basestring):
+            indent = indent * ' '
+        self.indent = indent
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+        elif indent is not None:
+            self.item_separator = ','
+        if default is not None:
+            self.default = default
+        self.encoding = encoding
+
+    def default(self, o):
+        """Implement this method in a subclass such that it returns
+        a serializable object for ``o``, or calls the base implementation
+        (to raise a ``TypeError``).
+
+        For example, to support arbitrary iterators, you could
+        implement default like this::
+
+            def default(self, o):
+                try:
+                    iterable = iter(o)
+                except TypeError:
+                    pass
+                else:
+                    return list(iterable)
+                return JSONEncoder.default(self, o)
+
+        """
+        raise TypeError(repr(o) + " is not JSON serializable")
+
+    def encode(self, o):
+        """Return a JSON string representation of a Python data structure.
+
+        >>> from simplejson import JSONEncoder
+        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
+        '{"foo": ["bar", "baz"]}'
+
+        """
+        # This is for extremely simple cases and benchmarks.
+        if isinstance(o, basestring):
+            if isinstance(o, str):
+                _encoding = self.encoding
+                if (_encoding is not None
+                        and not (_encoding == 'utf-8')):
+                    o = o.decode(_encoding)
+            if self.ensure_ascii:
+                return encode_basestring_ascii(o)
+            else:
+                return encode_basestring(o)
+        # This doesn't pass the iterator directly to ''.join() because the
+        # exceptions aren't as detailed.  The list call should be roughly
+        # equivalent to the PySequence_Fast that ''.join() would do.
+        chunks = self.iterencode(o, _one_shot=True)
+        if not isinstance(chunks, (list, tuple)):
+            chunks = list(chunks)
+        if self.ensure_ascii:
+            return ''.join(chunks)
+        else:
+            return u''.join(chunks)
+
+    def iterencode(self, o, _one_shot=False):
+        """Encode the given object and yield each string
+        representation as available.
+
+        For example::
+
+            for chunk in JSONEncoder().iterencode(bigobject):
+                mysocket.write(chunk)
+
+        """
+        if self.check_circular:
+            markers = {}
+        else:
+            markers = None
+        if self.ensure_ascii:
+            _encoder = encode_basestring_ascii
+        else:
+            _encoder = encode_basestring
+        if self.encoding != 'utf-8':
+            def _encoder(o, _orig_encoder=_encoder, _encoding=self.encoding):
+                if isinstance(o, str):
+                    o = o.decode(_encoding)
+                return _orig_encoder(o)
+
+        def floatstr(o, allow_nan=self.allow_nan,
+                _repr=FLOAT_REPR, _inf=PosInf, _neginf=-PosInf):
+            # Check for specials. Note that this type of test is processor
+            # and/or platform-specific, so do tests which don't depend on
+            # the internals.
+
+            if o != o:
+                text = 'NaN'
+            elif o == _inf:
+                text = 'Infinity'
+            elif o == _neginf:
+                text = '-Infinity'
+            else:
+                return _repr(o)
+
+            if not allow_nan:
+                raise ValueError(
+                    "Out of range float values are not JSON compliant: " +
+                    repr(o))
+
+            return text
+
+
+        key_memo = {}
+        if (_one_shot and c_make_encoder is not None
+                and self.indent is None):
+            _iterencode = c_make_encoder(
+                markers, self.default, _encoder, self.indent,
+                self.key_separator, self.item_separator, self.sort_keys,
+                self.skipkeys, self.allow_nan, key_memo, self.use_decimal,
+                self.namedtuple_as_object, self.tuple_as_array,
+                self.bigint_as_string, self.item_sort_key,
+                Decimal)
+        else:
+            _iterencode = _make_iterencode(
+                markers, self.default, _encoder, self.indent, floatstr,
+                self.key_separator, self.item_separator, self.sort_keys,
+                self.skipkeys, _one_shot, self.use_decimal,
+                self.namedtuple_as_object, self.tuple_as_array,
+                self.bigint_as_string, self.item_sort_key,
+                Decimal=Decimal)
+        try:
+            return _iterencode(o, 0)
+        finally:
+            key_memo.clear()
+
+
+class JSONEncoderForHTML(JSONEncoder):
+    """An encoder that produces JSON safe to embed in HTML.
+
+    To embed JSON content in, say, a script tag on a web page, the
+    characters &, < and > should be escaped. They cannot be escaped
+    with the usual entities (e.g. &amp;) because they are not expanded
+    within <script> tags.
+    """
+
+    def encode(self, o):
+        # Override JSONEncoder.encode because it has hacks for
+        # performance that make things more complicated.
+        chunks = self.iterencode(o, True)
+        if self.ensure_ascii:
+            return ''.join(chunks)
+        else:
+            return u''.join(chunks)
+
+    def iterencode(self, o, _one_shot=False):
+        chunks = super(JSONEncoderForHTML, self).iterencode(o, _one_shot)
+        for chunk in chunks:
+            chunk = chunk.replace('&', '\\u0026')
+            chunk = chunk.replace('<', '\\u003c')
+            chunk = chunk.replace('>', '\\u003e')
+            yield chunk
+
+
+def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
+        _key_separator, _item_separator, _sort_keys, _skipkeys, _one_shot,
+        _use_decimal, _namedtuple_as_object, _tuple_as_array,
+        _bigint_as_string, _item_sort_key,
+        ## HACK: hand-optimized bytecode; turn globals into locals
+        False=False,
+        True=True,
+        ValueError=ValueError,
+        basestring=basestring,
+        Decimal=Decimal,
+        dict=dict,
+        float=float,
+        id=id,
+        int=int,
+        isinstance=isinstance,
+        list=list,
+        long=long,
+        str=str,
+        tuple=tuple,
+    ):
+    if _item_sort_key and not callable(_item_sort_key):
+        raise TypeError("item_sort_key must be None or callable")
+
+    def _iterencode_list(lst, _current_indent_level):
+        if not lst:
+            yield '[]'
+            return
+        if markers is not None:
+            markerid = id(lst)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = lst
+        buf = '['
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = '\n' + (_indent * _current_indent_level)
+            separator = _item_separator + newline_indent
+            buf += newline_indent
+        else:
+            newline_indent = None
+            separator = _item_separator
+        first = True
+        for value in lst:
+            if first:
+                first = False
+            else:
+                buf = separator
+            if isinstance(value, basestring):
+                yield buf + _encoder(value)
+            elif value is None:
+                yield buf + 'null'
+            elif value is True:
+                yield buf + 'true'
+            elif value is False:
+                yield buf + 'false'
+            elif isinstance(value, (int, long)):
+                yield ((buf + str(value))
+                       if (not _bigint_as_string or
+                           (-1 << 53) < value < (1 << 53))
+                           else (buf + '"' + str(value) + '"'))
+            elif isinstance(value, float):
+                yield buf + _floatstr(value)
+            elif _use_decimal and isinstance(value, Decimal):
+                yield buf + str(value)
+            else:
+                yield buf
+                if isinstance(value, list):
+                    chunks = _iterencode_list(value, _current_indent_level)
+                else:
+                    _asdict = _namedtuple_as_object and getattr(value, '_asdict', None)
+                    if _asdict and callable(_asdict):
+                        chunks = _iterencode_dict(_asdict(),
+                                                  _current_indent_level)
+                    elif _tuple_as_array and isinstance(value, tuple):
+                        chunks = _iterencode_list(value, _current_indent_level)
+                    elif isinstance(value, dict):
+                        chunks = _iterencode_dict(value, _current_indent_level)
+                    else:
+                        chunks = _iterencode(value, _current_indent_level)
+                for chunk in chunks:
+                    yield chunk
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield '\n' + (_indent * _current_indent_level)
+        yield ']'
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode_dict(dct, _current_indent_level):
+        if not dct:
+            yield '{}'
+            return
+        if markers is not None:
+            markerid = id(dct)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = dct
+        yield '{'
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = '\n' + (_indent * _current_indent_level)
+            item_separator = _item_separator + newline_indent
+            yield newline_indent
+        else:
+            newline_indent = None
+            item_separator = _item_separator
+        first = True
+        if _item_sort_key:
+            items = dct.items()
+            items.sort(key=_item_sort_key)
+        elif _sort_keys:
+            items = dct.items()
+            items.sort(key=lambda kv: kv[0])
+        else:
+            items = dct.iteritems()
+        for key, value in items:
+            if isinstance(key, basestring):
+                pass
+            # JavaScript is weakly typed for these, so it makes sense to
+            # also allow them.  Many encoders seem to do something like this.
+            elif isinstance(key, float):
+                key = _floatstr(key)
+            elif key is True:
+                key = 'true'
+            elif key is False:
+                key = 'false'
+            elif key is None:
+                key = 'null'
+            elif isinstance(key, (int, long)):
+                key = str(key)
+            elif _skipkeys:
+                continue
+            else:
+                raise TypeError("key " + repr(key) + " is not a string")
+            if first:
+                first = False
+            else:
+                yield item_separator
+            yield _encoder(key)
+            yield _key_separator
+            if isinstance(value, basestring):
+                yield _encoder(value)
+            elif value is None:
+                yield 'null'
+            elif value is True:
+                yield 'true'
+            elif value is False:
+                yield 'false'
+            elif isinstance(value, (int, long)):
+                yield (str(value)
+                       if (not _bigint_as_string or
+                           (-1 << 53) < value < (1 << 53))
+                           else ('"' + str(value) + '"'))
+            elif isinstance(value, float):
+                yield _floatstr(value)
+            elif _use_decimal and isinstance(value, Decimal):
+                yield str(value)
+            else:
+                if isinstance(value, list):
+                    chunks = _iterencode_list(value, _current_indent_level)
+                else:
+                    _asdict = _namedtuple_as_object and getattr(value, '_asdict', None)
+                    if _asdict and callable(_asdict):
+                        chunks = _iterencode_dict(_asdict(),
+                                                  _current_indent_level)
+                    elif _tuple_as_array and isinstance(value, tuple):
+                        chunks = _iterencode_list(value, _current_indent_level)
+                    elif isinstance(value, dict):
+                        chunks = _iterencode_dict(value, _current_indent_level)
+                    else:
+                        chunks = _iterencode(value, _current_indent_level)
+                for chunk in chunks:
+                    yield chunk
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield '\n' + (_indent * _current_indent_level)
+        yield '}'
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode(o, _current_indent_level):
+        if isinstance(o, basestring):
+            yield _encoder(o)
+        elif o is None:
+            yield 'null'
+        elif o is True:
+            yield 'true'
+        elif o is False:
+            yield 'false'
+        elif isinstance(o, (int, long)):
+            yield (str(o)
+                   if (not _bigint_as_string or
+                       (-1 << 53) < o < (1 << 53))
+                       else ('"' + str(o) + '"'))
+        elif isinstance(o, float):
+            yield _floatstr(o)
+        elif isinstance(o, list):
+            for chunk in _iterencode_list(o, _current_indent_level):
+                yield chunk
+        else:
+            _asdict = _namedtuple_as_object and getattr(o, '_asdict', None)
+            if _asdict and callable(_asdict):
+                for chunk in _iterencode_dict(_asdict(), _current_indent_level):
+                    yield chunk
+            elif (_tuple_as_array and isinstance(o, tuple)):
+                for chunk in _iterencode_list(o, _current_indent_level):
+                    yield chunk
+            elif isinstance(o, dict):
+                for chunk in _iterencode_dict(o, _current_indent_level):
+                    yield chunk
+            elif _use_decimal and isinstance(o, Decimal):
+                yield str(o)
+            else:
+                if markers is not None:
+                    markerid = id(o)
+                    if markerid in markers:
+                        raise ValueError("Circular reference detected")
+                    markers[markerid] = o
+                o = _default(o)
+                for chunk in _iterencode(o, _current_indent_level):
+                    yield chunk
+                if markers is not None:
+                    del markers[markerid]
+
+    return _iterencode
diff --git a/script/test/diffcalc (copy)/simplejson/ordered_dict.py b/script/test/diffcalc (copy)/simplejson/ordered_dict.py
new file mode 100644
index 0000000..87ad888
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/ordered_dict.py	
@@ -0,0 +1,119 @@
+"""Drop-in replacement for collections.OrderedDict by Raymond Hettinger
+
+http://code.activestate.com/recipes/576693/
+
+"""
+from UserDict import DictMixin
+
+# Modified from original to support Python 2.4, see
+# http://code.google.com/p/simplejson/issues/detail?id=53
+try:
+    all
+except NameError:
+    def all(seq):
+        for elem in seq:
+            if not elem:
+                return False
+        return True
+
+class OrderedDict(dict, DictMixin):
+
+    def __init__(self, *args, **kwds):
+        if len(args) > 1:
+            raise TypeError('expected at most 1 arguments, got %d' % len(args))
+        try:
+            self.__end
+        except AttributeError:
+            self.clear()
+        self.update(*args, **kwds)
+
+    def clear(self):
+        self.__end = end = []
+        end += [None, end, end]         # sentinel node for doubly linked list
+        self.__map = {}                 # key --> [key, prev, next]
+        dict.clear(self)
+
+    def __setitem__(self, key, value):
+        if key not in self:
+            end = self.__end
+            curr = end[1]
+            curr[2] = end[1] = self.__map[key] = [key, curr, end]
+        dict.__setitem__(self, key, value)
+
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
+        key, prev, next = self.__map.pop(key)
+        prev[2] = next
+        next[1] = prev
+
+    def __iter__(self):
+        end = self.__end
+        curr = end[2]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[2]
+
+    def __reversed__(self):
+        end = self.__end
+        curr = end[1]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[1]
+
+    def popitem(self, last=True):
+        if not self:
+            raise KeyError('dictionary is empty')
+        # Modified from original to support Python 2.4, see
+        # http://code.google.com/p/simplejson/issues/detail?id=53
+        if last:
+            key = reversed(self).next()
+        else:
+            key = iter(self).next()
+        value = self.pop(key)
+        return key, value
+
+    def __reduce__(self):
+        items = [[k, self[k]] for k in self]
+        tmp = self.__map, self.__end
+        del self.__map, self.__end
+        inst_dict = vars(self).copy()
+        self.__map, self.__end = tmp
+        if inst_dict:
+            return (self.__class__, (items,), inst_dict)
+        return self.__class__, (items,)
+
+    def keys(self):
+        return list(self)
+
+    setdefault = DictMixin.setdefault
+    update = DictMixin.update
+    pop = DictMixin.pop
+    values = DictMixin.values
+    items = DictMixin.items
+    iterkeys = DictMixin.iterkeys
+    itervalues = DictMixin.itervalues
+    iteritems = DictMixin.iteritems
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, self.items())
+
+    def copy(self):
+        return self.__class__(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        d = cls()
+        for key in iterable:
+            d[key] = value
+        return d
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedDict):
+            return len(self)==len(other) and \
+                   all(p==q for p, q in  zip(self.items(), other.items()))
+        return dict.__eq__(self, other)
+
+    def __ne__(self, other):
+        return not self == other
diff --git a/script/test/diffcalc (copy)/simplejson/scanner.py b/script/test/diffcalc (copy)/simplejson/scanner.py
new file mode 100644
index 0000000..54593a3
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/scanner.py	
@@ -0,0 +1,77 @@
+"""JSON token scanner
+"""
+import re
+def _import_c_make_scanner():
+    try:
+        from simplejson._speedups import make_scanner
+        return make_scanner
+    except ImportError:
+        return None
+c_make_scanner = _import_c_make_scanner()
+
+__all__ = ['make_scanner']
+
+NUMBER_RE = re.compile(
+    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
+    (re.VERBOSE | re.MULTILINE | re.DOTALL))
+
+def py_make_scanner(context):
+    parse_object = context.parse_object
+    parse_array = context.parse_array
+    parse_string = context.parse_string
+    match_number = NUMBER_RE.match
+    encoding = context.encoding
+    strict = context.strict
+    parse_float = context.parse_float
+    parse_int = context.parse_int
+    parse_constant = context.parse_constant
+    object_hook = context.object_hook
+    object_pairs_hook = context.object_pairs_hook
+    memo = context.memo
+
+    def _scan_once(string, idx):
+        try:
+            nextchar = string[idx]
+        except IndexError:
+            raise StopIteration
+
+        if nextchar == '"':
+            return parse_string(string, idx + 1, encoding, strict)
+        elif nextchar == '{':
+            return parse_object((string, idx + 1), encoding, strict,
+                _scan_once, object_hook, object_pairs_hook, memo)
+        elif nextchar == '[':
+            return parse_array((string, idx + 1), _scan_once)
+        elif nextchar == 'n' and string[idx:idx + 4] == 'null':
+            return None, idx + 4
+        elif nextchar == 't' and string[idx:idx + 4] == 'true':
+            return True, idx + 4
+        elif nextchar == 'f' and string[idx:idx + 5] == 'false':
+            return False, idx + 5
+
+        m = match_number(string, idx)
+        if m is not None:
+            integer, frac, exp = m.groups()
+            if frac or exp:
+                res = parse_float(integer + (frac or '') + (exp or ''))
+            else:
+                res = parse_int(integer)
+            return res, m.end()
+        elif nextchar == 'N' and string[idx:idx + 3] == 'NaN':
+            return parse_constant('NaN'), idx + 3
+        elif nextchar == 'I' and string[idx:idx + 8] == 'Infinity':
+            return parse_constant('Infinity'), idx + 8
+        elif nextchar == '-' and string[idx:idx + 9] == '-Infinity':
+            return parse_constant('-Infinity'), idx + 9
+        else:
+            raise StopIteration
+
+    def scan_once(string, idx):
+        try:
+            return _scan_once(string, idx)
+        finally:
+            memo.clear()
+
+    return scan_once
+
+make_scanner = c_make_scanner or py_make_scanner
diff --git a/script/test/diffcalc (copy)/simplejson/tool.py b/script/test/diffcalc (copy)/simplejson/tool.py
new file mode 100644
index 0000000..73370db
--- /dev/null
+++ b/script/test/diffcalc (copy)/simplejson/tool.py	
@@ -0,0 +1,39 @@
+r"""Command-line tool to validate and pretty-print JSON
+
+Usage::
+
+    $ echo '{"json":"obj"}' | python -m simplejson.tool
+    {
+        "json": "obj"
+    }
+    $ echo '{ 1.2:3.4}' | python -m simplejson.tool
+    Expecting property name: line 1 column 2 (char 2)
+
+"""
+import sys
+import simplejson as json
+
+def main():
+    if len(sys.argv) == 1:
+        infile = sys.stdin
+        outfile = sys.stdout
+    elif len(sys.argv) == 2:
+        infile = open(sys.argv[1], 'rb')
+        outfile = sys.stdout
+    elif len(sys.argv) == 3:
+        infile = open(sys.argv[1], 'rb')
+        outfile = open(sys.argv[2], 'wb')
+    else:
+        raise SystemExit(sys.argv[0] + " [infile [outfile]]")
+    try:
+        obj = json.load(infile,
+                        object_pairs_hook=json.OrderedDict,
+                        use_decimal=True)
+    except ValueError, e:
+        raise SystemExit(e)
+    json.dump(obj, outfile, sort_keys=True, indent='    ', use_decimal=True)
+    outfile.write('\n')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/script/test/diffcalc (copy)/startup/__init__.py b/script/test/diffcalc (copy)/startup/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/startup/_common_imports.py b/script/test/diffcalc (copy)/startup/_common_imports.py
new file mode 100644
index 0000000..89f5fdb
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/_common_imports.py	
@@ -0,0 +1,66 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+
+from __future__ import absolute_import
+
+import os, sys
+
+from diffcalc.hardware import ScannableHardwareAdapter
+import diffcalc.hkl.you.geometry
+from diffcalc.ub.persistence import UbCalculationNonPersister, UBCalculationJSONPersister
+from diffcalc import settings
+import diffcalc.util
+
+try:
+    __IPYTHON__  # @UndefinedVariable
+    IPYTHON = True
+except NameError:
+    IPYTHON = False
+
+try:
+    from gda.device.scannable.scannablegroup import ScannableGroup
+    from gdascripts.scannable.dummy import SingleInputDummy as Dummy
+    from diffcmd.diffcmd_utils import alias_commands
+    GDA = True  
+except ImportError:
+    # Not running in gda environment so fall back to minigda emulation
+    from diffcalc.gdasupport.minigda.scannable import ScannableGroup
+    from diffcalc.gdasupport.minigda.scannable import SingleFieldDummyScannable as Dummy
+    GDA = False
+
+
+HELP_STRING = \
+"""Quick:  https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst
+Manual: http://diffcalc.readthedocs.io/en/latest/youmanual.html
+Type:   > help ub
+        > help hkl"""
+
+
+if GDA:
+    from gda.configuration.properties import LocalProperties  # @UnresolvedImport
+    var_folder = LocalProperties.get("gda.var")
+    diffcalc_persistance_path = os.path.join(var_folder, 'diffcalc')
+    if not os.path.exists(diffcalc_persistance_path):
+        print "Making diffcalc var folder:'%s'" % diffcalc_persistance_path
+        os.makedirs(diffcalc_persistance_path)
+    settings.ubcalc_persister = UBCalculationJSONPersister(diffcalc_persistance_path)
+# else: should have been set if outside GDA
+
+
+
diff --git a/script/test/diffcalc (copy)/startup/_demo.py b/script/test/diffcalc (copy)/startup/_demo.py
new file mode 100644
index 0000000..811cde6
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/_demo.py	
@@ -0,0 +1,151 @@
+'''
+Created on 19 Feb 2017
+
+@author: zrb13439
+'''
+
+import diffcmd.ipython
+
+try:
+    __IPYTHON__  # @UndefinedVariable
+    IPYTHON = True
+except NameError:
+    IPYTHON = False
+    
+
+GEOMETRIES = ['sixc', 'fivec', 'fourc', 'i16', 'i21']
+
+
+def echo(cmd):
+    print "\n>>> " + str(cmd)
+
+    
+def print_heading(s):
+    print '\n' + '=' * len(s) + '\n' + s + '\n' + '=' * len(s)
+
+
+class Demo(object):
+    
+    def __init__(self, namespace, geometry):
+        self.namespace = namespace
+        assert geometry in GEOMETRIES
+        self.geometry = geometry
+
+    def all(self):
+        self.orient()
+        self.constrain()
+        self.scan()
+                 
+    def orient(self):
+        print_heading('Orientation demo')
+        self.remove_test_ubcalc()
+        
+        pos_cmd_001 = {
+            'sixc': 'pos sixc [0 60 0 30 90 0]', # mu, delta, gam, eta, chi, phi
+            'i16': 'pos sixc [0 90 30 0 60 0]', #  phi, chi, eta, mu, delta, gam
+            'i21': 'pos fourc [60 30 0 0]',
+            'fivec': 'pos fivec [60 0 30 90 0]',
+            'fourc': 'pos fourc [60 30 90 0]'
+            }[self.geometry]
+ 
+        pos_cmd_011 = {
+            'sixc': 'pos sixc [0 90 0 45 45 90]', # mu, delta, gam, eta, chi, phi
+            'i16': 'pos sixc [90 45 45 0 90 0]', #  phi, chi, eta, mu, delta, gam
+            'i21': 'pos fourc [90 90 0 0]',
+            'fivec': 'pos fivec [90 0 45 45 90]',
+            'fourc': 'pos fourc [90 45 45 90]'
+            }[self.geometry]
+                   
+        self.echorun_magiccmd_list([
+            'help ub',
+            'pos wl 1',
+            "newub 'test'",
+            "setlat 'cubic' 1 1 1 90 90 90",
+            'ub',
+            'c2th [0 0 1]',
+            pos_cmd_001,
+            'addref [0 0 1]',
+            'c2th [0 1 1]',
+            pos_cmd_011,
+            'addref [0 1 1]',
+            'ub',
+            'checkub'])
+        
+    def constrain(self):
+        print_heading('Constraint demo')
+        con_qaz_cmd = '' if self.geometry in ('fourc', 'i21') else 'con qaz 90'
+        con_mu_cmd = 'con mu 0' if self.geometry in ('sixc', 'i16') else ''
+        setmin_chi = 'setmin chi -180' if self.geometry == 'i21' else 'setmin chi 0'
+        setmin_phi = 'setmin phi -180' if self.geometry == 'i21' else ''
+        setmax_phi = 'setmax phi 180' if self.geometry == 'i21' else ''
+        self.echorun_magiccmd_list([
+            'help hkl',
+            con_qaz_cmd,
+            'con a_eq_b',
+            con_mu_cmd,
+            'con',
+            'setmin delta 0',
+            setmin_chi,
+            setmin_phi,
+            setmax_phi])
+            
+    def scan(self):
+        print_heading('Scanning demo')
+        if self.geometry == 'i16':
+            diff_name = 'sixc'
+        elif self.geometry == 'i21':
+            diff_name = 'fourc'
+        else:
+            diff_name = self.geometry
+        self.echorun_magiccmd_list([
+            'setnphi [0 0 1]' if self.geometry == 'i21' else '',
+            'pos hkl [0 0 1]' if self.geometry == 'i21' else 'pos hkl [1 0 0]',
+            'scan delta 40 90 10 hkl ct 1',
+            'pos hkl [0 1 0]',
+            'scan h 0 1 .2 k l %s ct 1' % diff_name,
+            'con psi',
+            'scan psi 0 90 10 hkl [1 0 1] eta chi phi ct .1'])
+ 
+    def echorun_magiccmd_list(self, magic_cmd_list):
+        for cmd in magic_cmd_list:
+            self.echorun_magiccmd(cmd)
+            
+    def remove_test_ubcalc(self):
+        try:
+            eval("rmub('test')", self.namespace)
+        except (OSError, KeyError):
+            pass
+ 
+    def echorun_magiccmd(self, magic_cmd):
+        if IPYTHON:
+            from IPython import get_ipython
+            echo(magic_cmd)
+            get_ipython().magic(magic_cmd) 
+        else:  # Python
+            # python's help is interactive. Handle specially 
+            if magic_cmd == 'help ub':
+                
+                echo("help ub")
+                exec("print ub.__doc__", self.namespace)
+                return
+            if magic_cmd == 'help hkl':
+                echo("help(hkl)")
+                exec("print hkl.__doc__", self.namespace)
+                return  
+            
+            # Echo the Python version of the magic command   
+            tokens = diffcmd.ipython.tokenify(magic_cmd)
+            if not tokens:
+                return
+            python_cmd = tokens.pop(0) + '(' + ', '.join(tokens) + ')'
+            python_cmd = python_cmd.replace('[, ', '[')
+            python_cmd = python_cmd.replace(',]', ']')
+            python_cmd = python_cmd.replace(', ]', ']')
+            echo(python_cmd)
+            
+            # Run the Python version of the magic command
+            elements = diffcmd.ipython.parse(magic_cmd, self.namespace)
+            func = elements.pop(0)
+            result = func(*elements)
+            if result:
+                print result
diff --git a/script/test/diffcalc (copy)/startup/_make_sixcircle_manual.py b/script/test/diffcalc (copy)/startup/_make_sixcircle_manual.py
new file mode 100644
index 0000000..fb81203
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/_make_sixcircle_manual.py	
@@ -0,0 +1,44 @@
+from startup._common_imports import *
+
+
+diffcalc.util.COLOURISE_TERMINAL_OUTPUT = False
+
+### Create dummy scannables ###
+print "Dummy scannables: sixc(mu, delta, gam, eta, chi, phi) and en"
+mu = Dummy('mu')
+delta = Dummy('delta')
+gam = Dummy('gam')
+eta = Dummy('eta')
+chi = Dummy('chi')
+phi = Dummy('phi')
+_sixc = ScannableGroup('sixc', (mu, delta, gam, eta, chi, phi))
+en = Dummy('en')
+en.level = 3
+
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(_sixc, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.SixCircle()  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group= _sixc
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+
+
+# For manual!
+from diffcalc.ub.persistence import UbCalculationNonPersister
+settings.ubcalc_persister = UbCalculationNonPersister()
+
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+
+DIFFCALC_ROOT = os.sep.join(
+    os.path.realpath(diffcalc.__file__).split(os.sep)[:-2])
+
+MANUALS_TO_MAKE = [
+    os.path.join(
+        DIFFCALC_ROOT, 'doc', 'source', 'youmanual_template.rst'),
+    os.path.join(
+        DIFFCALC_ROOT, 'README_template.rst')]
+
+print 'MANUALS_TO_MAKE: ', MANUALS_TO_MAKE
diff --git a/script/test/diffcalc (copy)/startup/api/__init__.py b/script/test/diffcalc (copy)/startup/api/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/startup/api/sixcircle.py b/script/test/diffcalc (copy)/startup/api/sixcircle.py
new file mode 100644
index 0000000..bf61331
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/api/sixcircle.py	
@@ -0,0 +1,73 @@
+
+from __future__ import absolute_import
+
+
+from diffcalc import settings
+from diffcalc.hkl.you.geometry import SixCircle
+from diffcalc.hardware import DummyHardwareAdapter
+import diffcalc.util  # @UnusedImport
+
+
+# Disable error handling designed for interactive use
+diffcalc.util.DEBUG = True
+
+
+# Configure and import diffcalc objects
+settings.hardware = DummyHardwareAdapter(('mu', 'delta', 'gam', 'eta', 'chi', 'phi'))
+settings.geometry = SixCircle()  # @UndefinedVariable
+
+
+# These must be imported AFTER the settings have been configured
+from diffcalc.dc import dcyou as dc
+from diffcalc.ub import ub
+from diffcalc import hardware
+from diffcalc.hkl.you import hkl
+
+# Set some limits
+hardware.setmin('gam', -179)
+hardware.setmax('gam', 179)
+
+# These demos reproduce the outline in the developer guide
+def demo_all():
+    demo_orient()
+    demo_motion()
+
+
+def demo_orient():
+
+    ub.listub()
+    
+    # Create a new ub calculation and set lattice parameters
+    ub.newub('test')
+    ub.setlat('cubic', 1, 1, 1, 90, 90, 90)
+    
+    # Add 1st reflection (demonstrating the hardware adapter)
+    settings.hardware.wavelength = 1
+    ub.c2th([1, 0, 0])                 # energy from hardware
+    settings.hardware.position = 0, 60, 0, 30, 0, 0
+    ub.addref([1, 0, 0])# energy and position from hardware
+    
+    # Add 2nd reflection (this time without the harware adapter)
+    ub.c2th([0, 1, 0], 12.39842)
+    ub.addref([0, 1, 0], [0, 60, 0, 30, 0, 90], 12.39842)
+    
+    # check the state
+    ub.ub()
+    ub.checkub()
+
+
+def demo_motion():
+    dc.angles_to_hkl((0., 60., 0., 30., 0., 0.))
+    hkl.con('qaz', 90)
+    hkl.con('a_eq_b')
+    hkl.con('mu', 0)
+    
+    hardware.setmin('delta', 0)
+    dc.hkl_to_angles(1, 0, 0)
+
+
+demo_all()
+    
+    
+    
+    
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/startup/beamlinespecific/__init__.py b/script/test/diffcalc (copy)/startup/beamlinespecific/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/startup/beamlinespecific/i21.py b/script/test/diffcalc (copy)/startup/beamlinespecific/i21.py
new file mode 100644
index 0000000..c82c0ff
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/beamlinespecific/i21.py	
@@ -0,0 +1,340 @@
+'''
+Created on 19 Feb 2017
+
+@author: zrb13439
+'''
+from diffcalc.gdasupport.minigda.scannable import ScannableMotionWithScannableFieldsBase,\
+    ScannableBase
+from math import pi
+
+# TP_HELP="""
+# Use the Scannables tplab, tplabx, tplaby, tplabz to move the configured tool point in
+# the lab frame. For example to move it to the centre of the diffractomter:
+# 
+#    >>> pos tplab [0 0 0]  # Move the toolpoint 
+#     
+# use 'settp' to change the configured toolpoint in the phi frame:
+# 
+#    >>> pos tphi [0 0 1]  # will not move anything
+#    
+# or use it with no args to make the location in the phi frame currently in
+# the centre of the diffracomtter the tool point. i.e. to make the tblab
+# report back [0 0 0]
+# """
+TP_HELP="""
+For help with sa, tp_phi and tp_lab see: http://confluence.diamond.ac.uk/x/CBIAB
+"""
+
+from diffcalc.hkl.you.geometry import calcETA, calcCHI, calcPHI
+
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+DEBUG = False
+
+def calc_tp_lab(tp_phi_tuple, eta, chi, phi, xyz_eta=[0, 0, 0]):
+    tp_phi = matrix(tp_phi_tuple).T
+    ETA = calcETA(eta * TORAD)
+    CHI = calcCHI(chi * TORAD)
+    PHI = calcPHI(phi * TORAD)
+    xyz_eta = matrix(xyz_eta).T
+    
+    tp_lab = ETA * (xyz_eta + (CHI * PHI * tp_phi))
+    return list(tp_lab.T.tolist()[0])
+
+
+def calc_tp_eta(tp_phi_tuple, chi, phi):
+    return calc_tp_lab(tp_phi_tuple, 0, chi, phi, [0, 0, 0])
+
+
+def move_lab_origin_into_phi(chi, phi, xyz_eta_tuple):
+    # the inverse of calc_tp_lab with tp_lab=0:
+    CHI = calcCHI(chi * TORAD)
+    PHI = calcPHI(phi * TORAD)
+    xyz_eta = matrix(xyz_eta_tuple).T
+    try:
+        #work in IPython with numpy
+        tp_phi = PHI.I * CHI.I * (-1.0 * xyz_eta)
+    except:
+        # work in GDA using jama_matrix_wrapper - definitely not nice
+        tp_phi = PHI.I * CHI.I * (xyz_eta.__mul__(-1.0))
+    return list(tp_phi.T.tolist()[0])
+    
+
+def _format_vector(vector, fmt = '%7.4f'):
+    vals = [fmt % e for e in vector]
+    return ' '.join(vals)
+
+
+class I21SampleStage(ScannableMotionWithScannableFieldsBase):
+    
+    def __init__(self, name, pol_scn, tilt_scn, az_scn, xyz_eta_scn):
+        
+        self.setName(name)
+        self._scn_list = [pol_scn, tilt_scn, az_scn]
+        self.xyz_eta_scn = xyz_eta_scn
+        
+        self.setInputNames([pol_scn.getName(), tilt_scn.getName(), az_scn.getName()])  # note, names copied below
+        self.setOutputFormat(['%7.5f'] * 3)
+        self.completeInstantiation()
+        
+        #  tp_phi is the TARGET tool point to end up at the diffractometer centre
+        self.tp_phi = [0, 0, 0]
+        
+        self.tp_phi_scannable = I21SampleStage.TpPhiScannable('tp_phi', self)
+        self.centre_toolpoint = True
+    
+    def asynchronousMoveTo(self, pos_triple):
+
+        if len(pos_triple) != 3:
+            raise ValueError(self.getName() + ' device expects three inputs')
+        
+        # Move pol, tilt & az (None if not to be moved)
+        pol, tilt, az = pos_triple
+        if pol is not None:
+            self._scn_list[0].asynchronousMoveTo(pol)
+        if tilt is not None:
+            self._scn_list[1].asynchronousMoveTo(tilt)
+        if az is not None:
+            self._scn_list[2].asynchronousMoveTo(az)
+        
+        if self.centre_toolpoint:  
+            _, tilt, az = self.completePosition(pos_triple)
+            chi = tilt
+            phi = az
+            tp_offset_eta = calc_tp_eta(self.tp_phi, chi, phi)
+            if DEBUG:
+                print ('{Correcting xyz_eta for '
+                       'tilt(chi)=%.2f & az(phi)=%.2f}' % (tilt, az)).rjust(79)
+            xyz = [-1 * e for e in tp_offset_eta]
+            self.xyz_eta_scn.asynchronousMoveTo(xyz)
+               
+    def rawGetPosition(self):
+        return [scn.getPosition() for scn in self._scn_list]
+    
+    def getFieldPosition(self, i):
+        return self._scn_list[i].getPosition()
+    
+    def isBusy(self):
+        return (any([scn.isBusy() for scn in self._scn_list])
+                or self.xyz_eta_scn.isBusy())
+    
+    def waitWhileBusy(self):
+        for scn in self._scn_list:
+            scn.waitWhileBusy()
+        self.xyz_eta_scn.waitWhileBusy()
+        
+    def __repr__(self):
+        
+        # Sample angle columns
+        pos = self.getPosition()
+        formatted_values = self.formatPositionFields(pos)
+        
+        sa_col = []
+        sa_col.append('%s:' % self.getName())
+        sa_col.append('%s:   %s (eta)' % (self._scn_list[0].getName(),formatted_values[0]))
+        sa_col.append('%s:    %s (chi)' % (self._scn_list[1].getName(),formatted_values[1]))
+        sa_col.append('%s: %s (phi)' % (self._scn_list[2].getName(),formatted_values[2]))
+        sa_col_width = len(sa_col[2])
+        
+        # Toolpoint column
+        xyz_eta = list(self.xyz_eta_scn.getPosition())
+        eta, chi, phi = self.getEulerPosition()
+        tp_lab = calc_tp_lab(self.tp_phi, eta, chi, phi, xyz_eta)
+        
+        tp_col = []
+        tp_col.append('')
+        tp_col.append('tp_phi : %s (set)' % _format_vector(self.tp_phi))
+        tp_col.append('tp_lab : %s' % _format_vector(tp_lab))
+        tp_col.append('xyz_eta: %s' % _format_vector(xyz_eta))
+        
+        # Combine columns
+        lines = []
+        while sa_col or tp_col:
+            sa_row = sa_col.pop(0) if sa_col else ''
+            tp_row = tp_col.pop(0) if tp_col else ''
+            lines.append(sa_row.ljust(sa_col_width + 3) + tp_row)
+        
+        if self.centre_toolpoint:
+            lines.append("\nToolpoint centring ENABLED (disable with toolpoint_off)")
+        else:
+            lines.append("\nToolpoint centring DISABLED (enable with toolpoint_on)")
+        # Add some help
+        return '\n'.join(lines) + TP_HELP
+    
+    def getEulerPosition(self):
+        pol, tilt, az = self.getPosition()
+        eta, chi, phi = pol,  tilt, az
+        return eta, chi, phi
+
+    class TpPhiScannable(ScannableBase):
+    
+        def __init__(self, name, i21_sample_stage):
+            self.name = name
+            self.i21_sample_stage = i21_sample_stage
+            self.inputNames = [name + 'x', name +'y', name + 'z']
+            self.outputFormat = ['% 6.4f'] * 3
+            self.level = 3
+    
+        def isBusy(self):
+            return False
+    
+        def waitWhileBusy(self):
+            return
+    
+        def asynchronousMoveTo(self, new_position):
+            if len(new_position) != 3:
+                raise TypeError('Expected 3 element target')
+            self.i21_sample_stage.tp_phi = list(new_position)
+    
+        def getPosition(self):
+            return list(self.i21_sample_stage.tp_phi)
+        
+    def zerosample(self):
+        """Calculate tp_phi from the currently centred sample location."""
+        _, chi, phi = self.getEulerPosition()
+        xyz_eta_tuple = list(self.xyz_eta_scn.getPosition())
+        tp_phi = move_lab_origin_into_phi(chi, phi, xyz_eta_tuple)
+        self.tp_phi = tp_phi
+        print "tp_phi set to: %s" % tp_phi
+        
+    def centresample(self):
+        """Centre the sample. Equivilent to moving sa to its current position."""
+        self.asynchronousMoveTo([None, None, None])
+        self.waitWhileBusy()
+            
+
+class I21DiffractometerStage(ScannableMotionWithScannableFieldsBase):
+    
+    def __init__(self, name, delta_scn, sample_stage_scn, delta_offset=0):
+        """Create diffractomter stage from 3circle sample axes and a
+        delta/tth axis.
+        
+        Both the chi and delta offsets are added to underlying scannable values
+        when *reading* the position. iu the same offset is subtracted when
+        *setting* the position. 
+        """
+        
+        self.sample_stage_scn = sample_stage_scn
+        self.delta_scn = delta_scn
+        self.delta_offset = delta_offset
+        self.setName(name)
+          
+        self.setInputNames(['delta', 'eta', 'chi', 'phi'])  # note, names copied below
+        self.setOutputFormat(['%7.4f'] * 4)
+        self.completeInstantiation()
+    
+    def asynchronousMoveTo(self, pos_quadruple):
+        if len(pos_quadruple) != 4:
+            raise ValueError(self.getName() + ' device expects four inputs')
+        
+        delta, eta, chi, phi = pos_quadruple              
+        pol = eta
+        #TODO revert to 'chi - self.chi_offset'once EPICS sign fixed
+        tilt = chi
+        az = phi
+        
+        if delta is not None:
+            self.delta_scn.asynchronousMoveTo(delta - self.delta_offset)
+        
+        if (pol is not None) or (tilt is not None) or (az is not None):
+            self.sample_stage_scn.asynchronousMoveTo([pol, tilt, az])
+               
+    def rawGetPosition(self):
+        delta = self.delta_scn.getPosition()
+        pol, tilt, az = self.sample_stage_scn.getPosition()
+        eta, chi, phi = pol, tilt, az
+        return delta + self.delta_offset, eta, chi, phi
+    
+    def getFieldPosition(self, i):
+        return self.getPosition()[i]
+    
+    def isBusy(self):
+        return self.delta_scn.isBusy() or self.sample_stage_scn.isBusy()
+    
+    def waitWhileBusy(self):
+        self.delta_scn.waitWhileBusy()
+        self.sample_stage_scn.waitWhileBusy()
+        
+    def __repr__(self):
+        vals = self.formatPositionFields(self.getPosition())
+        lines = []
+        for name, val, hint in zip(self.getInputNames(), vals, self.get_hints()):
+            lines.append('%-6s : %s%s' % (name, val, hint))
+        return '\n'.join(lines)
+
+    def get_hints(self):
+        sample_names = self.sample_stage_scn.getInputNames()
+        hints = []
+        if self.delta_offset != 0:
+            sign = '+' if self.delta_offset > 0 else '-'
+            hints.append(' (%s %s %s)' % 
+                         (self.delta_scn.getName(), sign, abs(self.delta_offset)))                # delta
+        else:
+            hints.append(' (%s)' % self.delta_scn.getName())                # delta
+        hints.append(' (%s)' % sample_names[0])                         # eta
+        hints.append(' (%s)' % sample_names[1])                         # chi
+        hints.append(' (%s)' % sample_names[2])                         # phi
+        return hints
+ 
+ 
+class I21TPLab(ScannableMotionWithScannableFieldsBase):
+    
+    def __init__(self, name, sample_stage_scn):
+        
+        self.name = name
+        self.sample_stage_scn = sample_stage_scn
+          
+        self.setInputNames([name + 'x', name + 'y', name + 'z'])  # note, names copied below
+        self.setOutputFormat(['%7.4f'] * 3)
+        self.completeInstantiation()
+        self.setAutoCompletePartialMoveToTargets(True)
+
+    
+    def rawAsynchronousMoveTo(self, tp_lab_target):
+        if len(tp_lab_target) != 3:
+            raise ValueError(self.getName() + ' device expects three inputs')
+        
+        if None in tp_lab_target:
+            raise ValueError('unexpected None in tp_lab_target: ', tp_lab_target)
+
+        eta, chi, phi = self.sample_stage_scn.getEulerPosition()        
+        ETA = calcETA(eta * TORAD)
+
+        # Move tp target from lab frame inwards to eta frame
+        tp_lab_target = matrix(tp_lab_target).T
+        tp_eta_target = ETA.T * tp_lab_target  # ETA.I == ETA.T
+
+        # Move configured tp from phi frame outwards to eta frame
+        tp_eta = calc_tp_eta(self.sample_stage_scn.tp_phi, chi, phi)
+        
+        # Calculate offset required to align the two
+        xyz_eta = tp_eta_target - matrix(tp_eta).T
+        xyz_eta = xyz_eta.T.tolist()[0]
+        
+        self.sample_stage_scn.xyz_eta_scn.asynchronousMoveTo(xyz_eta)        
+        
+    def rawGetPosition(self):
+        tp_phi = list(self.sample_stage_scn.tp_phi)
+        eta, chi, phi = self.sample_stage_scn.getEulerPosition()
+        xyz_eta = list(self.sample_stage_scn.xyz_eta_scn.getPosition())
+        
+        tp_lab = calc_tp_lab(tp_phi, eta, chi, phi, xyz_eta)
+        return tp_lab
+    
+    def getFieldPosition(self, i):
+        return self.getPosition()[i]
+    
+    def isBusy(self):
+        return self.sample_stage_scn.xyz_eta_scn.isBusy()
+    
+    def waitWhileBusy(self):
+        self.sample_stage_scn.xyz_eta_scn.waitWhileBusy()
+        
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/startup/fivecircle.py b/script/test/diffcalc (copy)/startup/fivecircle.py
new file mode 100644
index 0000000..3f32be5
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/fivecircle.py	
@@ -0,0 +1,36 @@
+from startup._common_imports import *
+import startup._demo
+
+### Create dummy scannables ###
+print "Diffcalc creating dummy Scannables as _fivec and en were not found"
+delta = Dummy('delta')
+gam = Dummy('gam')
+eta = Dummy('eta')
+chi = Dummy('chi')
+phi = Dummy('phi')
+_fivec = ScannableGroup('_fivec', (delta, gam, eta, chi, phi))
+en = Dummy('en')
+en.level = 3
+
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(_fivec, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.FiveCircle()  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group = _fivec
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+    
+lastub()  # Load the last ub calculation used
+
+# Set some limits
+setmin('gam', -179)
+setmax('gam', 179)
+
+demo = startup._demo.Demo(globals(), 'fivec')
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/startup/fourcircle.py b/script/test/diffcalc (copy)/startup/fourcircle.py
new file mode 100644
index 0000000..f260b4f
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/fourcircle.py	
@@ -0,0 +1,31 @@
+from startup._common_imports import *
+import startup._demo
+
+### Create dummy scannables ###
+delta = Dummy('delta')
+eta = Dummy('eta')
+chi = Dummy('chi')
+phi = Dummy('phi')
+_fourc = ScannableGroup('_fourc', (delta, eta, chi, phi))
+en = Dummy('en')
+en.level = 3
+
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(_fourc, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.FourCircle()  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group= _fourc
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+
+# Load the last ub calculation used
+lastub() 
+
+demo = startup._demo.Demo(globals(), 'fourc')
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/startup/i06.py b/script/test/diffcalc (copy)/startup/i06.py
new file mode 100644
index 0000000..0bc08f1
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/i06.py	
@@ -0,0 +1,56 @@
+from startup._common_imports import *  # @UnusedWildImport
+from diffcalc.gdasupport.minigda.scannable import ScannableMotionWithScannableFieldsBase  # @UnusedImport
+from diffcalc.gdasupport.minigda.scannable import DummyPD
+if not GDA:    
+    import startup._demo
+else:
+#     import __main__  # @UnresolvedImport
+    from __main__ import dd2th,ddth,denergy  # @UnresolvedImport
+LOCAL_MANUAL = "http://confluence.diamond.ac.uk/pages/viewpage.action?pageId=31853413"
+# Diffcalc i06-1
+# ======== === 
+# delta    dd2th
+# eta      ddth
+# chi      dummy
+# phi      dummy
+
+
+### Create dummy scannables ###
+if GDA:  
+    print "!!! Starting LIVE diffcalc with delta(dd2th), eta(ddth), chi(dummy), phi(dummy) and denergy." 
+    delta = dd2th
+    eta = ddth
+    en=denergy
+    if float(en.getPosition()) == 0: # no energy value - dummy mode
+        en(800)
+    
+else:   
+    delta = Dummy('delta')
+    eta = Dummy('eta')
+    en = Dummy('en')
+    en(1500)
+    
+chi = DummyPD('chi')
+phi = DummyPD('phi')
+
+_fourc = ScannableGroup('_fourc', (delta, eta, chi, phi))
+en.level = 3
+ 
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(_fourc, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.FourCircle()  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group= _fourc
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+ 
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+ 
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+ 
+# Load the last ub calculation used
+lastub() 
+if not GDA:
+    demo = startup._demo.Demo(globals(), 'fourc')
diff --git a/script/test/diffcalc (copy)/startup/i10.py b/script/test/diffcalc (copy)/startup/i10.py
new file mode 100644
index 0000000..e076ce6
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/i10.py	
@@ -0,0 +1,138 @@
+from startup._common_imports import *  # @UnusedWildImport
+
+if not GDA:    
+    import startup._demo
+else:
+#     import __main__  # @UnresolvedImport
+    from __main__ import tth,th,chi,pgm_energy, simtth,simth,simchi,simalpha # @UnresolvedImport
+
+LOCAL_MANUAL = ""
+
+SIM_MODE=False
+
+### Create dummy scannables ###
+if GDA:  
+    ###map GDA scannable to diffcalc axis name###
+    delta=tth
+    eta=th
+    chi=chi
+    phi=Dummy("phi")
+    en=pgm_energy
+    if float(en.getPosition()) == 0: # no energy value - dummy mode
+        en(800)
+else:
+    #Create dummy axes to run outside GDA in IPython#   
+    delta = Dummy('delta')
+    eta = Dummy('eta')
+    chi = Dummy('chi')
+    phi = Dummy('phi')
+    en = Dummy('en')
+    en(800)
+
+_fourc = ScannableGroup('_fourc', (delta, eta, chi, phi))
+en.level = 3
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 0.001
+settings.hardware = ScannableHardwareAdapter(_fourc, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.FourCircle()  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group= _fourc
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+ 
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+ 
+### Load the last ub calculation used
+lastub()
+ 
+### Set i10 specific limits
+def setLimitsAndCuts(delta,eta,chi,phi):
+    ''' set motor limits for diffcalc, these are within the actual motor limits
+    '''
+    setmin(delta, -60.0)
+    setmax(delta, 165.0) 
+    setmin(eta, -94.408)
+    setmax(eta, 190.591)
+    setmin(chi, 85.5)
+    setmax(chi, 94.5)
+    setmin(phi, 0)
+    setmax(phi, 360.0)
+    print "Current hardware limits set to:"
+    hardware()
+
+setLimitsAndCuts(delta,eta,chi,phi)
+
+if GDA:
+    def swithMotors(delta, mu, eta, chi, phi):
+        import __main__
+        from diffcalc.dc import dcyou as _dc
+        
+        ### update Wrap i21 names to get diffcalc names
+        _fourc = ScannableGroup('_fourc', (delta, mu, eta, chi, phi))
+        #update diffcalc objects
+        __main__.settings.hardware = ScannableHardwareAdapter(_fourc, __main__.en, ESMTGKeV)  # @UndefinedVariable
+        __main__.settings.geometry = diffcalc.hkl.you.geometry.FourCircle()  # @UndefinedVariable
+        __main__.settings.energy_scannable = __main__.en  # @UndefinedVariable
+        __main__.settings.axes_scannable_group= _fourc
+        __main__.settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+        
+        __main__.fourc=DiffractometerScannableGroup('fourc', _dc, _fourc)
+        __main__.hkl = Hkl('hkl', _fourc, _dc)
+        __main__.h, __main__.k, __main__.l = hkl.h, hkl.k, hkl.l
+
+        from diffcalc.gdasupport.you import _virtual_angles
+        from diffcalc.gdasupport.scannable.simulation import SimulatedCrystalCounter
+        from diffcalc.gdasupport.scannable.wavelength import Wavelength
+        __main__.hklverbose = Hkl('hklverbose', _fourc, _dc, _virtual_angles)
+        __main__.wl = Wavelength('wl',__main__.en,ESMTGKeV)  # @UndefinedVariable
+        __main__.ct = SimulatedCrystalCounter('ct', _fourc, __main__.settings.geometry,__main__.wl)  # @UndefinedVariable
+        
+    def stopMotors(delta, eta, chi, phi):
+        delta.stop()
+        eta.stop()
+        chi.stop()
+        phi.stop()
+        
+    def simdc():
+        ''' switch to use dummy motors in diffcalc
+        '''
+        print "Stop real motors"
+        stopMotors(tth,th,chi,phi)
+        
+        global SIM_MODE
+        SIM_MODE=True
+        import __main__
+        __main__.en=Dummy("en")
+        print "Set energy to 12398.425 eV in simulation mode!"
+        __main__.en(12398.425) #1 Angstrom wavelength @UndefinedVariable
+        print "Switch to simulation motors"
+        swithMotors(simtth,simalpha,simth,simchi,phi)
+        setLimitsAndCuts(simtth,simalpha,simth,simchi,phi)
+        
+    def realdc():
+        ''' switch to use real motors in diffcalc
+        '''
+        print "Stop simulation motors"
+        stopMotors(simtth,simalpha,simth,simchi,phi)
+        
+        global SIM_MODE
+        SIM_MODE=False
+        import __main__
+        print "Set energy to current beamline energy in real mode!"
+        __main__.en=pgm_energy
+        print "Switch to real motors"
+        swithMotors(tth,th,chi,phi)
+        setLimitsAndCuts(tth,th,chi,phi)
+     
+    from gda.jython.commands.GeneralCommands import alias  # @UnresolvedImport
+    print "Created commands: 'simdc' and 'realdc' to switch between real and simulated motors."
+    alias("simdc")
+    alias("realdc")
+
+### Demo ###
+if not GDA:
+    demo = demo = startup._demo.Demo(globals(), 'fourc')
diff --git a/script/test/diffcalc (copy)/startup/i13.py b/script/test/diffcalc (copy)/startup/i13.py
new file mode 100644
index 0000000..e02ff2f
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/i13.py	
@@ -0,0 +1,186 @@
+from diffcalc.util import x_rotation, y_rotation, z_rotation, TORAD, TODEG
+from startup._common_imports import *
+if not GDA:
+    import startup._demo
+
+
+if '_fivec' in globals() and 'en' in globals():
+    # Assume we are running in a live GDA deployment with a _fivec ScannableGroup
+    # with axes named: delta, gam, eta, chi, phi.
+    # Ensure that these five Scannables exist.
+    # There must also be Scannable en for moving and reading the energy
+    print "Diffcalc using predefined _fivec and en Scannables"
+else:
+    ### Create dummy scannables ###
+    print "Diffcalc creating dummy Scannables as _fivec and en were not found"
+    delta = Dummy('delta')
+    gam = Dummy('gam')
+    eta = Dummy('eta')
+    chi = Dummy('chi')
+    phi = Dummy('phi')
+    _fivec = ScannableGroup('_fivec', (delta, gam, eta, chi, phi))
+    en = Dummy('en')
+    en.level = 3
+
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(_fivec, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.FiveCircle()
+settings.energy_scannable = en
+settings.axes_scannable_group = _fivec
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+
+
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+ 
+  
+# Load the last ub calculation used  
+lastub()
+
+# 
+# setmax(delta, 28)
+# setmin(delta, -1)
+# setmin(gam, 0)
+# setmax(gam, 16)
+# setmin(eta, -10)
+# setmax(eta, 10)
+# setmin(chi, 90 - 12)
+# setmax(chi, 90 + 12)
+# setmin(phi, -88)
+# setmax(phi, 88)
+# setcut(phi, -90)
+# hardware()
+
+
+setmax(delta, 90)
+setmin(delta, -1)
+setmin(gam, 0)
+setmax(gam, 90)
+setmin(eta, -90)
+setmax(eta, 90)
+setmin(chi, -10)
+setmax(chi, 100)
+setmin(phi, -88)
+setmax(phi, 88)
+setcut(phi, -90)
+hardware()
+
+
+
+def X(th_deg):
+    return x_rotation(th_deg * TORAD)
+
+
+def Y(th_deg):
+    return y_rotation(th_deg * TORAD)
+                      
+
+def Z(th_deg):
+    return z_rotation(th_deg * TORAD)
+
+
+WEDGE = X(15)
+
+
+if not GDA:
+    demo = startup._demo.Demo(globals(), 'fivec')
+    
+    
+"""
+Fivec, no real limits, working out U matrix
+===========================================
+U = xyz_rotation([-0.70711, 0.70711, 0.00000], 54.73561 * TORAD)
+setu U
+pos en 20
+con qaz 90
+con a_eq_b
+UBCALC
+
+   name:     2017-03-07-i13
+
+   n_phi:     -0.00000  -0.00000   1.00000
+   n_hkl:      0.57735   0.57735   0.57735 <- set
+   miscut:
+      angle:   0.00003
+      axis:    0.70711  -0.70711   0.00000
+
+CRYSTAL
+
+   name:         Si111
+
+   a, b, c:    5.43000   5.43000   5.43000
+              90.00000  90.00000  90.00000
+
+   B matrix:   1.15712   0.00000   0.00000
+               0.00000   1.15712   0.00000
+               0.00000   0.00000   1.15712
+
+UB MATRIX
+
+   U matrix:   0.78868  -0.21133  -0.57735
+              -0.21132   0.78867  -0.57735
+               0.57735   0.57735   0.57735
+
+      angle:  54.73564
+       axis:   0.70711  -0.70711   0.00000
+
+   UB matrix:  0.91260  -0.24453  -0.66807
+              -0.24453   0.91259  -0.66807
+               0.66807   0.66807   0.66807
+
+REFLECTIONS
+
+     ENERGY     H     K     L     DELTA      GAM      ETA      CHI      PHI  TAG
+   1 20.000  1.00  1.00  1.00   11.3483   0.0000   5.6741  90.0000  45.0000  
+   2 20.000  4.00  0.00  0.00   26.3978   0.0000  13.1989  35.2644 -15.0000  
+
+In [80]: listub
+UB calculations in: /Users/zrb13439/.diffcalc/i13
+
+ 0) 2017-03-07-i13  14 Mar 2017 (14:35)
+ 1) test            07 Mar 2017 (11:38)
+ 
+ In [81]: hardware
+    -1.0 <= delta <=   90.0 (cut: -180.0)
+     0.0 <=   gam <=   90.0 (cut: -180.0)
+   -90.0 <=   eta <=   90.0 (cut: -180.0)
+   -10.0 <=   chi <=  100.0 (cut: -180.0)
+  -180.0 <=   phi <=  180.0 (cut:  -90.0)
+Note: When auto sector/transforms are used,
+       cuts are applied before checking limits.
+       
+Add in delta and gamma constraintss:
+In [85]: atan(28/16)*TODEG
+Out[85]: 45.0
+
+In [86]: atan(28/16.)*TODEG
+Out[86]: 60.25511870305777
+
+In [87]: con qaz 60
+    qaz  : 60.0000
+    a_eq_b
+    mu   : 0.0000
+
+In [88]: sim hkl [4 0 0]
+_fivec would move to:
+  delta :   22.6459
+    gam :   13.9379
+    eta :   59.2132
+    chi :    8.8270
+    phi :  -63.0717
+
+  alpha :    7.5752
+   beta :    7.5752
+    naz :    4.5446
+    psi :   90.0000
+    qaz :   60.0000
+    tau :   54.7356
+  theta :   13.1989
+
+""""
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/startup/i16.py b/script/test/diffcalc (copy)/startup/i16.py
new file mode 100644
index 0000000..f3c1306
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/i16.py	
@@ -0,0 +1,71 @@
+from startup._common_imports import *
+from diffcalc.hkl.you.geometry import YouPosition
+import diffcalc.hkl.you.geometry
+if not GDA:
+    import startup._demo
+
+LOCAL_MANUAL = 'http://confluence.diamond.ac.uk/display/I16/Diffcalc%20(i16)'
+
+class SixCircleI16(diffcalc.hkl.you.geometry.YouGeometry):
+    def __init__(self):
+        diffcalc.hkl.you.geometry.YouGeometry.__init__(self, 'sixc', {})
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        #    i16:   phi, chi, eta, mu, delta, gam
+        # H. You:   mu, delta, nu, eta, chi, phi
+        phi_phys, chi_phys, eta_phys, mu_phys, delta_phys, gam_phys = physical_angle_tuple
+        return YouPosition(mu_phys, delta_phys, gam_phys, eta_phys, chi_phys, phi_phys, unit='DEG')
+
+    def internal_position_to_physical_angles(self, internal_position):
+        clone_position = internal_position.clone()
+        clone_position.changeToDegrees()
+        mu_phys, delta_phys, nu_phys, eta_phys, chi_phys, phi_phys = clone_position.totuple()
+        return phi_phys, chi_phys, eta_phys, mu_phys, delta_phys, nu_phys
+
+
+if GDA:
+    from scannable.extraNameHider import ExtraNameHider
+    dummy_energy = Dummy('dummy_energy')
+    simple_energy = ExtraNameHider('energy', dummy_energy)  # @UndefinedVariable
+    if 'euler' not in locals():
+        raise Exception('Expecting a device called euler')
+
+else: # Assume running in dummy mode outside GDA
+    mu = Dummy('mu')
+    delta = Dummy('delta')
+    gam = Dummy('gam')
+    eta = Dummy('eta')
+    chi = Dummy('chi')
+    phi = Dummy('phi')
+    euler = ScannableGroup('euler', (phi, chi, eta, mu, delta, gam))
+    en = simple_energy = Dummy('energy')
+    en.level = 3
+
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(euler, simple_energy, ESMTGKeV)
+settings.geometry = SixCircleI16()
+settings.energy_scannable = simple_energy
+settings.axes_scannable_group= euler
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+hkl.setLevel(6)
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+    
+lastub()  # Load the last ub calculation used
+
+# iPython removes the actual command from namespace
+diffcalc.hardware.setrange(chi, -2, 100)
+diffcalc.hardware.setrange(eta, -2, 92)
+diffcalc.hardware.setrange(delta, -2, 145)
+diffcalc.hardware.setrange(gam, -2, 145)
+setcut(phi, -180)
+
+if not GDA:
+    demo = startup._demo.Demo(globals(), 'i16')
diff --git a/script/test/diffcalc (copy)/startup/i21.py b/script/test/diffcalc (copy)/startup/i21.py
new file mode 100644
index 0000000..3f11f78
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/i21.py	
@@ -0,0 +1,465 @@
+from startup._common_imports import *  # @UnusedWildImport
+from diffcalc.gdasupport.minigda.scannable import ScannableMotionWithScannableFieldsBase  # @UnusedImport
+from startup.beamlinespecific.i21 import I21SampleStage, I21DiffractometerStage, I21TPLab
+from diffcalc.hkl.you.geometry import YouGeometry, YouPosition
+from diffcalc.hkl.you.constraints import NUNAME
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+if not GDA:    
+    import startup._demo
+else:
+#     import __main__  # @UnresolvedImport
+    from __main__ import x,y,z,th,chi,phi,delta,m5tth, energy, simx,simy,simz,simth,simchi,simphi,simdelta,simm5tth # @UnresolvedImport
+
+LOCAL_MANUAL = "http://confluence.diamond.ac.uk/x/UoIQAw"
+# Diffcalc i21
+# ======== === 
+# delta    delta or m5tth
+# eta      th
+# chi      90deg-chi
+# phi      phi
+
+SIM_MODE=False
+
+class FourCircleI21(YouGeometry):
+    """For a diffractometer with angles:
+          delta, eta, chi, phi
+    """
+    def __init__(self, beamline_axes_transform=None):
+        YouGeometry.__init__(self, 'fourc', {'mu': 0, NUNAME: 0}, beamline_axes_transform)
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        # mu, delta, nu, eta, chi, phi
+        delta_phys, eta_phys, chi_phys, phi_phys = physical_angle_tuple
+        return YouPosition(0, delta_phys, 0, eta_phys, 90 - chi_phys, phi_phys, 'DEG')
+
+    def internal_position_to_physical_angles(self, internal_position):
+        clone_position = internal_position.clone()
+        clone_position.changeToDegrees()
+        _, delta_phys, _, eta_phys, chi_phys, phi_phys = clone_position.totuple()
+        return delta_phys, eta_phys, 90 - chi_phys, phi_phys
+
+
+### Create dummy scannables ###
+if GDA:  
+    xyz_eta = ScannableGroup('xyz_eta', [x, y, z])  # @UndefinedVariable
+else:   
+    delta = Dummy('delta')
+    m5tth = Dummy('m5tth')
+    th = Dummy('th')
+    chi = Dummy('chi')
+    phi = Dummy('phi')
+    x = Dummy('x')
+    y = Dummy('y')
+    z = Dummy('z')
+    xyz_eta = ScannableGroup('xyz_eta', [x, y, z])
+
+#support i21 non-concentric rotation motions
+sa = I21SampleStage('sa', th, chi, phi, xyz_eta)
+#th = sa.th
+#chi = sa.chi
+#phi = sa.phi
+
+tp_phi = sa.tp_phi_scannable
+
+tp_lab = I21TPLab('tp_lab', sa)
+tp_labx = tp_lab.tp_labx
+tp_laby = tp_lab.tp_laby
+tp_labz = tp_lab.tp_labz
+
+### Wrap i21 names to get diffcalc names - sample chamber
+_fourc = I21DiffractometerStage('_fourc', delta, sa)
+delta = _fourc.delta
+eta = _fourc.eta
+chi = _fourc.chi
+phi = _fourc.phi
+
+if GDA:
+    en=energy
+    if float(en.getPosition()) == 0: # no energy value - dummy?
+        en(800)
+
+else:
+    en = Dummy('en')
+    en(800)
+    
+en.level = 3
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 0.001
+settings.hardware = ScannableHardwareAdapter(_fourc, en, ESMTGKeV)
+beamline_axes_transform = matrix('0 0 1; 0 1 0; 1 0 0')
+settings.geometry = FourCircleI21(beamline_axes_transform=beamline_axes_transform)  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group= _fourc
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+ 
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+# fourc is created in diffcalc.gdasupport.you. Add some I21 hints into it
+fourc.hint_generator = _fourc.get_hints  # (the callablemethod) # @UndefinedVariable
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+ 
+### Load the last ub calculation used
+from diffcalc.ub.ub import lastub
+lastub()
+ 
+### Set i21 specific limits
+print "INFO: diffcalc limits set in $diffcalc/startup/i21.py taken from http://confluence.diamond.ac.uk/pages/viewpage.action?pageId=51413586"
+def setLimitsAndCuts(delta_angle, chi_angle, eta_angle, phi_angle):
+    ''' set motor limits for diffcalc, these are within the actual motor limits
+    '''
+    setmin(delta_angle, 0.0)
+    setmax(delta_angle, 180.0) #default to diode delta limits
+    setmin(chi_angle, -41.0)
+    setmax(chi_angle, 36.0)
+    setmin(eta_angle, 0.0)
+    setmax(eta_angle, 150.0)
+    setmin(phi_angle, -100.0)
+    setmax(phi_angle, 100.0)
+    #http://jira.diamond.ac.uk/browse/I21-361
+    setcut(eta_angle, 0.0)
+    setcut(phi_angle, -180.0)
+    print "Current hardware limits set to:"
+    hardware()
+
+setLimitsAndCuts(delta, chi, eta, phi)
+
+### Create i21 bespoke secondary hkl devices
+# Warning: this breaks the encapsulation provided by the diffcalc.dc.you public
+#          interface, and may be prone to breakage in future.
+
+print 'Creating i21 bespoke scannables:'
+
+from diffcalc.dc import dcyou as _dc
+from diffcalc.gdasupport.scannable.diffractometer import DiffractometerScannableGroup
+from diffcalc.gdasupport.scannable.hkl import Hkl
+
+print '- fourc_vessel & hkl_vessel'
+_fourc_vessel = I21DiffractometerStage('_fourc_vessel', m5tth, sa)
+fourc_vessel = DiffractometerScannableGroup('fourc_vessel', _dc, _fourc_vessel)
+fourc_vessel.hint_generator = _fourc_vessel.get_hints
+hkl_vessel = Hkl('hkl_vessel', _fourc_vessel, _dc)
+h_vessel, k_vessel, l_vessel = hkl_vessel.h, hkl_vessel.k, hkl_vessel.l
+
+print '- fourc_lowq & hkl_lowq'
+LOWQ_OFFSET_ADDED_TO_DELTA_WHEN_READING = -8
+_fourc_lowq = I21DiffractometerStage('_fourc_lowq', m5tth, sa,delta_offset=LOWQ_OFFSET_ADDED_TO_DELTA_WHEN_READING)
+fourc_lowq = DiffractometerScannableGroup('fourc_lowq', _dc, _fourc_lowq)
+fourc_lowq.hint_generator = _fourc_lowq.get_hints
+hkl_lowq = Hkl('hkl_lowq', _fourc_lowq, _dc)
+h_lowq, k_lowq, l_lowq = hkl_lowq.h, hkl_lowq.k, hkl_lowq.l
+
+print '- fourc_highq & hkl_highq'
+highq_OFFSET_ADDED_TO_DELTA_WHEN_READING = 0
+_fourc_highq = I21DiffractometerStage('_fourc_highq', m5tth, sa,delta_offset=highq_OFFSET_ADDED_TO_DELTA_WHEN_READING)
+fourc_highq = DiffractometerScannableGroup('fourc_highq', _dc, _fourc_highq)
+fourc_highq.hint_generator = _fourc_highq.get_hints
+hkl_highq = Hkl('hkl_highq', _fourc_highq, _dc)
+h_highq, k_highq, l_highq = hkl_highq.h, hkl_highq.k, hkl_highq.l
+
+# sample chamber
+print '- fourc_diode & hkl_diode'
+_fourc_diode = I21DiffractometerStage('_fourc_diode', delta, sa)
+fourc_diode = DiffractometerScannableGroup('fourc_diode', _dc, _fourc_diode)
+fourc_diode.hint_generator = _fourc_diode.get_hints
+hkl_diode = Hkl('hkl_diode', _fourc_diode, _dc)
+h_diode, k_diode, l_diode = hkl_diode.h, hkl_diode.k, hkl_diode.l
+
+def centresample():
+    sa.centresample()
+
+def zerosample():
+    '''zero on the currently centred sample location
+    '''
+    sa.zerosample()
+    
+def toolpoint_on():
+    '''Switch on tool point
+    '''
+    sa.centre_toolpoint = True
+
+def toolpoint_off():
+    '''Switch off tool point
+    '''
+    sa.centre_toolpoint = False
+    
+def usediode():
+    '''Use photo diode in sample chamber
+    '''
+    if SIM_MODE:
+        _fourc.delta_scn=simdelta
+        setmin(simdelta, 0)
+        setmax(simdelta, 180)
+        
+    else:
+        _fourc.delta_scn = delta
+        setmin(delta, 0)
+        setmax(delta, 180)
+    
+def usevessel():
+    '''Use spectrometer
+    '''
+    if SIM_MODE:
+        _fourc.delta_scn=simm5tth
+        setmin(simm5tth, 0)
+        setmax(simm5tth, 150)
+    else:
+        _fourc.delta_scn = m5tth  # note, if changed also update in _fourc_vessel constructor!
+        setmin(m5tth, 0)
+        setmax(m5tth, 150)
+    
+print "Created i21 bespoke commands: usediode, usevessel, centresample, zerosample, toolpoint_on, toolpoint_off"
+
+if GDA:
+    def swithMotors(sax, say, saz, sath, sachi, saphi, diodedelta, specm5tth):
+        import __main__
+        __main__.xyz_eta = ScannableGroup('xyz_eta', [sax, say, saz])  # @UndefinedVariable
+        #update support for i21 non-concentric rotation motions
+        __main__.sa = I21SampleStage('sa', sath, sachi, saphi,__main__.xyz_eta)  # @UndefinedVariable
+        
+        __main__.tp_phi = sa.tp_phi_scannable
+        
+        __main__.tp_lab = I21TPLab('tp_lab', __main__.sa)  # @UndefinedVariable
+        __main__.tp_labx = __main__.tp_lab.tp_labx  # @UndefinedVariable
+        __main__.tp_laby = __main__.tp_lab.tp_laby  # @UndefinedVariable
+        __main__.tp_labz = __main__.tp_lab.tp_labz  # @UndefinedVariable
+        
+        ### update Wrap i21 names to get diffcalc names
+        _fourc = I21DiffractometerStage('_fourc', diodedelta, __main__.sa)  # @UndefinedVariable
+        __main__.delta = _fourc.delta
+        __main__.eta = _fourc.eta
+        __main__.chi = _fourc.chi
+        __main__.phi = _fourc.phi
+            #update diffcalc objects
+        __main__.settings.hardware = ScannableHardwareAdapter(_fourc, __main__.en, ESMTGKeV)  # @UndefinedVariable
+        __main__.settings.geometry = FourCircleI21(beamline_axes_transform=beamline_axes_transform)  # @UndefinedVariable
+        __main__.settings.energy_scannable = __main__.en  # @UndefinedVariable
+        __main__.settings.axes_scannable_group= _fourc
+        __main__.settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+        
+        __main__.fourc=DiffractometerScannableGroup('fourc', _dc, _fourc)
+        __main__.fourc.hint_generator = _fourc.get_hints  # (the callabl emethod) # @UndefinedVariable
+        __main__.hkl = Hkl('hkl', _fourc, _dc)
+        __main__.h, __main__.k, __main__.l = hkl.h, hkl.k, hkl.l
+
+        from diffcalc.gdasupport.you import _virtual_angles
+        from diffcalc.gdasupport.scannable.simulation import SimulatedCrystalCounter
+        from diffcalc.gdasupport.scannable.wavelength import Wavelength
+        __main__.hklverbose = Hkl('hklverbose', _fourc, _dc, _virtual_angles)
+        __main__.wl = Wavelength('wl',__main__.en,ESMTGKeV)  # @UndefinedVariable
+        __main__.ct = SimulatedCrystalCounter('ct', _fourc, __main__.settings.geometry,__main__.wl)  # @UndefinedVariable
+        #update scannales: fourc_vessel & hkl_vessel'
+        _fourc_vessel = I21DiffractometerStage('_fourc_vessel', specm5tth, __main__.sa)  # @UndefinedVariable
+        __main__.fourc_vessel = DiffractometerScannableGroup('fourc_vessel', _dc, _fourc_vessel)
+        __main__.fourc_vessel.hint_generator = _fourc_vessel.get_hints
+        __main__.hkl_vessel = Hkl('hkl_vessel', _fourc_vessel, _dc)
+        __main__.h_vessel, __main__.k_vessel, __main__.l_vessel = hkl_vessel.h, hkl_vessel.k, hkl_vessel.l
+        
+        #Update scannables: fourc_lowq & hkl_lowq'
+        _fourc_lowq = I21DiffractometerStage('_fourc_lowq', specm5tth, __main__.sa,delta_offset=LOWQ_OFFSET_ADDED_TO_DELTA_WHEN_READING)  # @UndefinedVariable
+        __main__.fourc_lowq = DiffractometerScannableGroup('fourc_lowq', _dc, _fourc_lowq)
+        __main__.fourc_lowq.hint_generator = _fourc_lowq.get_hints
+        __main__.hkl_lowq = Hkl('hkl_lowq', _fourc_lowq, _dc)
+        __main__.h_lowq, __main__.k_lowq, __main__.l_lowq = hkl_lowq.h, hkl_lowq.k, hkl_lowq.l
+        
+        #Update scannables: fourc_highq & hkl_highq'
+        _fourc_highq = I21DiffractometerStage('_fourc_highq', specm5tth, __main__.sa,delta_offset=highq_OFFSET_ADDED_TO_DELTA_WHEN_READING)  # @UndefinedVariable
+        __main__.fourc_highq = DiffractometerScannableGroup('fourc_highq', _dc, _fourc_highq)
+        __main__.fourc_highq.hint_generator = _fourc_highq.get_hints
+        __main__.hkl_highq = Hkl('hkl_highq', _fourc_highq, _dc)
+        __main__.h_highq, __main__.k_highq, __main__.l_highq = hkl_highq.h, hkl_highq.k, hkl_highq.l
+        
+        #Update scannables: fourc_diode & hkl_diode'
+        _fourc_diode = I21DiffractometerStage('_fourc_diode', diodedelta, __main__.sa)  # @UndefinedVariable
+        __main__.fourc_diode = DiffractometerScannableGroup('fourc_diode', _dc, _fourc_diode)
+        __main__.fourc_diode.hint_generator = _fourc_diode.get_hints
+        __main__.hkl_diode = Hkl('hkl_diode', _fourc_diode, _dc)
+        __main__.h_diode, __main__.k_diode, __main__.l_diode = hkl_diode.h, hkl_diode.k, hkl_diode.l
+        
+    def stopMotors(sax, say, saz, sath, sachi, saphi, diodedelta, specm5tth):
+        sax.stop()
+        say.stop()
+        saz.stop()
+        sath.stop()
+        sachi.stop()
+        saphi.stop()
+        diodedelta.stop()
+        specm5tth.stop()
+        
+    def simdc():
+        ''' switch to use dummy motors in diffcalc
+        '''
+        print "Stop real motors"
+        stopMotors(x, y, z, th, chi, phi, delta, m5tth)
+        
+        global SIM_MODE
+        SIM_MODE=True
+        import __main__
+        __main__.en=Dummy("en")
+        print "Set energy to 12398.425 eV in simulation mode!"
+        __main__.en(12398.425) #1 Angstrom wavelength @UndefinedVariable
+        print "Switch to simulation motors"
+        swithMotors(simx,simy,simz,simth,simchi,simphi,simdelta,simm5tth)
+#         __main__.th = __main__.sa.simth  # @UndefinedVariable
+#         __main__.chi = __main__.sa.simchi  # @UndefinedVariable
+#         __main__.phi = __main__.sa.simphi  # @UndefinedVariable
+        setLimitsAndCuts(simdelta,simchi,simth,simphi)
+        
+    def realdc():
+        ''' switch to use real motors in diffcalc
+        '''
+        print "Stop simulation motors"
+        stopMotors(simx,simy,simz,simth,simchi,simphi,simdelta,simm5tth)
+        
+        global SIM_MODE
+        SIM_MODE=False
+        import __main__
+        print "Set energy to current beamline energy in real mode!"
+        __main__.en=energy
+        print "Switch to real motors"
+        swithMotors(x,y,z,th,chi,phi,delta,m5tth)
+#         __main__.th = __main__.sa.th  # @UndefinedVariable
+#         __main__.chi = __main__.sa.chi  # @UndefinedVariable
+#         __main__.phi = __main__.sa.phi  # @UndefinedVariable
+        setLimitsAndCuts(delta,chi,eta,phi)
+     
+    from gda.jython.commands.GeneralCommands import alias  # @UnresolvedImport
+    alias("usediode")
+    alias("usevessel")
+    alias("centresample")
+    alias("zerosample")
+    alias("toolpoint_on")
+    alias("toolpoint_off")
+    print "Created i21 bespoke commands: simdc, realdc"
+    alias("simdc")
+    alias("realdc")
+else:
+    from IPython.core.magic import register_line_magic  # @UnresolvedImport
+    from diffcmd.ipython import parse_line
+    if IPYTHON:
+        from IPython import get_ipython  # @UnresolvedImport @UnusedImport
+        register_line_magic(parse_line(usediode, globals()))
+        del usediode
+        register_line_magic(parse_line(usevessel, globals()))
+        del usevessel
+        register_line_magic(parse_line(centresample, globals()))
+        del centresample
+        register_line_magic(parse_line(zerosample, globals()))
+        del zerosample
+        register_line_magic(parse_line(toolpoint_on, globals()))
+        del toolpoint_on
+        register_line_magic(parse_line(toolpoint_off, globals()))
+        del toolpoint_off
+### Demo ###
+
+if not GDA:
+    class I21Demo(startup._demo.Demo):
+        
+        def __init__(self, namespace):
+            startup._demo.Demo.__init__(self, namespace, 'i21')
+        
+        def i21(self):
+            startup._demo.print_heading('i21 scannables demo')
+    
+            self.echorun_magiccmd_list([
+                'sa',
+                'pos th 1',
+                'pos chi 2',
+                'pos phi 3',
+                'pos m5tth 4',
+                'usevessel',
+                'fourc'])
+        
+    demo = I21Demo(globals())
+else: 
+    print "DIFFCALC demo:"
+    class I21Demo(object):
+        
+        def __init__(self, namespace):
+            self.namespace = namespace
+
+        def all(self):
+            self.orient()
+            self.constrain()
+            self.scan()
+            
+        def remove_test_ubcalc(self):
+            try:
+                eval("rmub('test')", self.namespace)
+            except (OSError, KeyError):
+                pass
+        
+        def executeCommand(self, cmd_list):
+            for cmd in cmd_list:
+                if cmd == 'help ub':
+                    print("help ub")
+                    exec("print ub.__doc__", self.namespace)
+                elif cmd == 'help hkl':
+                    print("help(hkl)")
+                    exec("print hkl.__doc__", self.namespace)
+                else:    
+                    exec(cmd, self.namespace) 
+    
+        def orient(self):
+            print
+            print "-"*100
+            print 'Orientation demo'
+            print
+            self.remove_test_ubcalc()
+            cmd_list=[
+                'help ub',
+                "from gda.jython.commands.ScannableCommands import pos; pos(wl, 10)",
+                "newub('test')",
+                "setlat('cubic', 1,1, 1, 90, 90, 90)",
+                'ub',
+                'c2th([0, 0, .1])',
+                'from gda.jython.commands.ScannableCommands import pos; pos(fourc, [60, 30, 0, 0])',
+                'addref([0, 0, .1])',
+                'c2th([0, .1, .1])',
+                'from gda.jython.commands.ScannableCommands import pos; pos(fourc, [90, 90, 0, 0])',
+                'addref([0, .1, .1])',
+                'ub',
+                'checkub']        
+            self.executeCommand(cmd_list)
+            
+        def constrain(self):
+            print
+            print "-"*100
+            print 'Constraint demo'
+            print
+            cmd_list=[
+                'help hkl',
+                'con(a_eq_b)',
+                'con',
+                'setmin(delta, 0)',
+                'setmin(chi, -180)',
+                'setmin(phi, -180)',
+                'setmax(phi, 180)']
+            self.executeCommand(cmd_list)
+    
+        def scan(self):
+            print
+            print "-"*100
+            print 'Scanning demo'
+            print
+            
+            cmd_list=[
+                'setnphi([0, 0, 1])',
+                'pos hkl([0, 0, .1])',
+                'scan(delta, 40, 90, 10, hkl, ct, 1)',
+                'pos(hkl, [0, .1, 0])',
+                'scan(h, 0, .1, .02, k, l, fourc, ct, 1)',
+                'con(psi)',
+                'scan(psi, 0, 90, 10, hkl, [.1, 0, .1], eta, chi, phi, ct, .1)']
+            self.executeCommand(cmd_list)
+
+
+
diff --git a/script/test/diffcalc (copy)/startup/sixcircle.py b/script/test/diffcalc (copy)/startup/sixcircle.py
new file mode 100644
index 0000000..af63df6
--- /dev/null
+++ b/script/test/diffcalc (copy)/startup/sixcircle.py	
@@ -0,0 +1,37 @@
+from startup._common_imports import *
+import startup._demo
+
+### Create dummy scannables ###
+mu = Dummy('mu')
+delta = Dummy('delta')
+gam = Dummy('gam')
+eta = Dummy('eta')
+chi = Dummy('chi')
+phi = Dummy('phi')
+_sixc = ScannableGroup('_sixc', (mu, delta, gam, eta, chi, phi))
+en = Dummy('en')
+en.level = 3
+
+
+### Configure and import diffcalc objects ###
+ESMTGKeV = 1
+settings.hardware = ScannableHardwareAdapter(_sixc, en, ESMTGKeV)
+settings.geometry = diffcalc.hkl.you.geometry.SixCircle()  # @UndefinedVariable
+settings.energy_scannable = en
+settings.axes_scannable_group= _sixc
+settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV
+
+from diffcalc.gdasupport.you import *  # @UnusedWildImport
+
+if GDA:
+    print "Running in GDA --- aliasing commands"
+    alias_commands(globals())
+
+# Load the last ub calculation used
+lastub()
+
+# Set some limits
+setmin('gam', -179)
+setmax('gam', 179)
+
+demo = startup._demo.Demo(globals(), 'sixc')
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/__init__.py b/script/test/diffcalc (copy)/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/dc/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/dc/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/dc/test_dcvlieg.py b/script/test/diffcalc (copy)/test/diffcalc/dc/test_dcvlieg.py
new file mode 100644
index 0000000..9c3bdda
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/dc/test_dcvlieg.py	
@@ -0,0 +1,707 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+from diffcalc import settings
+import pytest
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+try:
+    from gdascripts.pd.dummy_pds import DummyPD  # @UnusedImport
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+
+from diffcalc.gdasupport.scannable.base import ScannableGroup
+from diffcalc.gdasupport.scannable.diffractometer import \
+    DiffractometerScannableGroup
+from diffcalc.gdasupport.scannable.hkl import Hkl
+from diffcalc.gdasupport.scannable.parameter import \
+    DiffractionCalculatorParameter
+from diffcalc.gdasupport.scannable.slave_driver import \
+    NuDriverForSixCirclePlugin
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry, \
+    SixCircleGeometry, Fivec, Fourc
+from diffcalc.hardware import DummyHardwareAdapter
+from diffcalc.hardware import ScannableHardwareAdapter
+from test.tools import aneq_, mneq_
+from diffcalc.ub.persistence import UbCalculationNonPersister
+from diffcalc.util import DiffcalcException, MockRawInput
+from test.diffcalc import scenarios
+import diffcalc.util  # @UnusedImport to overide raw_input
+from diffcalc.gdasupport.minigda.command import sim
+
+diffcalc.util.DEBUG = True
+
+def prepareRawInput(listOfStrings):
+    diffcalc.util.raw_input = MockRawInput(listOfStrings)
+
+
+prepareRawInput([])
+
+
+def createDummyAxes(names):
+    result = []
+    for name in names:
+        result.append(DummyPD(name))
+    return result
+
+
+class BaseTestDiffractionCalculatorWithData(object):
+
+    def setSessionAndCalculation(self):
+        raise Exception("Abstract")
+
+    def setup_method(self):
+        self.geometry = SixCircleGammaOnArmGeometry()
+        self.hardware = DummyHardwareAdapter(
+            ('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
+        settings.hardware = self.hardware
+        settings.geometry = self.geometry
+        settings.ubcalc_persister = UbCalculationNonPersister()
+        from diffcalc.dc import dcvlieg as dc
+        reload(dc)
+        self.dc = dc
+        self.setSessionAndCalculation()
+        prepareRawInput([])
+
+    def setDataAndReturnObject(self, sessionScenario, calculationScenario):
+        self.sess = sessionScenario
+        self.calc = calculationScenario
+        return self
+
+    def test_angles_to_hkl(self):
+        with pytest.raises(DiffcalcException):
+            self.dc.angles_to_hkl((1, 2, 3, 4, 5, 6))  # no energy set
+        settings.hardware.energy = 10
+        with pytest.raises(DiffcalcException):
+            self.dc.angles_to_hkl((1, 2, 3, 4, 5, 6))  # no ub calculated 
+        s = self.sess
+        c = self.calc
+
+        # setup session info
+        self.dc.newub(s.name)
+        self.dc.setlat(s.name, *s.lattice)
+        r = s.ref1
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        r = s.ref2
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        self.dc.calcub()
+
+        # check the ubcalculation is okay before continuing
+        # (useful to check for typos!)
+        mneq_(self.dc.ubcalc.UB,
+              matrix(s.umatrix) * matrix(s.bmatrix), 4,
+              note="wrong UB matrix after calculating U")
+        # Test each hkl/position pair
+        for idx in range(len(c.hklList)):
+            hkl = c.hklList[idx]
+            pos = c.posList[idx]
+            # 1) specifying energy explicitely
+            ((h, k, l), params) = self.dc.angles_to_hkl(pos.totuple(), c.energy)
+            msg = ("wrong hkl calc for TestScenario=%s, AngleTestScenario"
+                   "=%s, pos=%s):\n  expected hkl=%f %f %f\n  returned hkl="
+                   "%f %f %f "
+                   % (s.name, c.tag, str(pos), hkl[0], hkl[1], hkl[2], h, k, l)
+                   )
+            assert [h, k, l] == pytest.approx(hkl, abs=.001)
+#             self.assert_((abs(h - hkl[0]) < .001) & (abs(k - hkl[1]) < .001)
+#                          & (abs(l - hkl[2]) < .001), msg)
+            # 2) specifying energy via hardware
+            settings.hardware.energy = c.energy
+            msg = ("wrong hkl calcualted for TestScenario=%s, "
+                   "AngleTestScenario=%s, pos=%s):\n  expected hkl=%f %f %f\n"
+                   "  returned hkl=%f %f %f " %
+                   (s.name, c.tag, str(pos), hkl[0], hkl[1], hkl[2], h, k, l))
+            ((h, k, l), params) = self.dc.angles_to_hkl(pos.totuple())
+            assert [h, k, l] == pytest.approx(hkl, abs=.001)
+            del params
+
+    def test_hkl_to_angles(self):
+        s = self.sess
+        c = self.calc
+
+        ## setup session info
+        self.dc.newub(s.name)
+        self.dc.setlat(s.name, *s.lattice)
+        r = s.ref1
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        r = s.ref2
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        self.dc.calcub()
+        # check the ubcalculation is okay before continuing
+        # (useful to check for typos !)
+        mneq_(self.dc.ubcalc.UB,
+              matrix(s.umatrix) * matrix(s.bmatrix), 4,
+              note="wrong UB matrix after calculating U")
+
+        ## setup calculation info
+        self.dc.hklmode(c.modeNumber)
+        # Set fixed parameters
+        if c.alpha != None:
+            self.dc.setpar('alpha', c.alpha)
+        if c.gamma != None:
+            self.dc.setpar('gamma', c.alpha)
+
+        # Test each hkl/position pair
+        for idx in range(len(c.hklList)):
+            (h, k, l) = c.hklList[idx]
+
+            expectedangles = \
+                self.geometry.internal_position_to_physical_angles(c.posList[idx])
+            (angles, params) = self.dc.hkl_to_angles(h, k, l, c.energy)
+            expectedAnglesStr = ("%f " * len(expectedangles)) % expectedangles
+            anglesString = ("%f " * len(angles)) % angles
+            namesString = (("%s " * len(self.hardware.get_axes_names()))
+                           % self.hardware.get_axes_names())
+            note = ("wrong position calcualted for TestScenario=%s, "
+                    "AngleTestScenario=%s, hkl=%f %f %f:\n"
+                    "                       { %s }\n"
+                    "  expected pos=%s\n  returned pos=%s "
+                    % (s.name, c.tag, h, k, l, namesString, expectedAnglesStr,
+                       anglesString))
+            mneq_(matrix([list(expectedangles)]), matrix([list(angles)]), 2,
+                  note=note)
+            del params
+
+    def testSimWithHklAndSixc(self):
+        dummyAxes = createDummyAxes(
+            ['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
+        dummySixcScannableGroup = ScannableGroup('sixcgrp', dummyAxes)
+        sixcdevice = DiffractometerScannableGroup(
+            'SixCircleGammaOnArmGeometry', self.dc, dummySixcScannableGroup)
+        hkldevice = Hkl('hkl', sixcdevice, self.dc)
+        with pytest.raises(TypeError):
+            sim()
+        with pytest.raises(TypeError):
+            sim(hkldevice)
+        with pytest.raises(TypeError):
+            sim(hkldevice, 1, 2, 3)
+        with pytest.raises(TypeError):
+            sim('not a proper scannable', 1)
+        with pytest.raises(TypeError):
+            sim(hkldevice, (1, 2, 'not a number'))
+        with pytest.raises(TypeError):
+            sim(hkldevice, 1)
+        with pytest.raises(ValueError):
+            sim(hkldevice, (1, 2, 3, 4))
+
+        s = self.sess
+        c = self.calc
+        # setup session info
+        self.dc.newub(s.name)
+        self.dc.setlat(s.name, *s.lattice)
+        r = s.ref1
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        r = s.ref2
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        self.dc.calcub()
+
+        # check the ubcalculation is okay before continuing
+        # (useful to check for typos!)
+        mneq_(self.dc.ubcalc.UB,
+              (matrix(s.umatrix) * (matrix(s.bmatrix))),
+              4, note="wrong UB matrix after calculating U")
+        self.hardware.energy = c.energy
+        # Test each hkl/position pair
+        for idx in range(len(c.hklList)):
+            hkl = c.hklList[idx]
+            pos = c.posList[idx].totuple()
+            sim(sixcdevice, pos)
+            sim(hkldevice, hkl)
+
+    def testCheckub(self):
+        ## setup session info
+        s = self.sess
+        self.dc.newub(s.name)
+        self.dc.setlat(s.name, *s.lattice)
+        r = s.ref1
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        r = s.ref2
+        self.dc.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        self.dc.calcub()
+        print "*** checkub ***"
+        print self.dc.checkub()
+        print "***************"
+
+
+class TestDiffractionCalculatorHklWithDataSess2Calc0(
+    BaseTestDiffractionCalculatorWithData):
+    def setSessionAndCalculation(self):
+        self.sess = scenarios.sessions()[1]
+        self.calc = self.sess.calculations[0]
+
+
+class TestDiffractionCalculatorHklWithDataSess3Calc0(
+    BaseTestDiffractionCalculatorWithData):
+    def setSessionAndCalculation(self):
+        self.sess = scenarios.sessions()[2]
+        self.calc = self.sess.calculations[0]
+
+
+class TestSixcBase(object):
+
+    def createDiffcalcAndScannables(self, geometryClass):
+        self.en = DummyPD('en')
+        dummy = createDummyAxes(
+            ['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
+        group = ScannableGroup('sixcgrp', dummy)
+        self.sixc = DiffractometerScannableGroup('sixc', None, group)
+        
+        self.hardware = DummyHardwareAdapter(
+            ('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
+        settings.hardware = ScannableHardwareAdapter(self.sixc, self.en)
+        settings.geometry = geometryClass()
+        settings.ubcalc_persister = UbCalculationNonPersister()
+        from diffcalc.dc import dcvlieg as dc
+        reload(dc)
+        self.dc = dc
+        
+
+        self.sixc.diffcalc = self.dc
+        self.hkl = Hkl('hkl', self.sixc, self.dc)
+
+
+class TestFourcBase(object):
+
+    def createDiffcalcAndScannables(self):
+        self.en = DummyPD('en')
+        dummy = createDummyAxes(['delta', 'omega', 'chi', 'phi'])
+        scannableGroup = ScannableGroup('fourcgrp', dummy)
+        self.fourc = DiffractometerScannableGroup(
+            'fourc', None, scannableGroup)
+        
+        settings.hardware = ScannableHardwareAdapter(self.fourc, self.en)
+        settings.geometry = Fourc()
+        settings.ubcalc_persister = UbCalculationNonPersister()
+
+        from diffcalc.dc import dcvlieg as dc
+        reload(dc)
+        self.dc = dc
+        
+        self.fourc.diffcalc = self.dc
+        self.hkl = Hkl('hkl', self.fourc, self.dc)
+
+
+class SixCircleGammaOnArmTest(TestSixcBase):
+
+    def setup_method(self):
+        TestSixcBase.createDiffcalcAndScannables(self,
+                                                 SixCircleGammaOnArmGeometry)
+        self.hklverbose = Hkl('hkl', self.sixc, self.dc,
+                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
+        settings.hardware.set_cut('phi', -180)  # cut phi at -180 to match dif
+        self.orient()
+
+    def orient(self):
+        self.dc.newub('b16_270608')
+        self.dc.setlat('xtal', 3.8401, 3.8401, 5.43072)
+        self.en(12.39842 / 1.24)
+        self.sixc([5.000, 22.790, 0.000, 1.552, 22.400, 14.255])
+        self.dc.addref([1, 0, 1.0628])
+        self.sixc([5.000, 22.790, 0.000, 4.575, 24.275, 101.320])
+        self.dc.addref([0, 1, 1.0628])
+        self.dc.checkub()
+
+    def testDiffractionCalculatorScannableIntegration(self):
+        betain = DiffractionCalculatorParameter('betain', 'betain',
+                                                self.dc.parameter_manager)
+        betain.asynchronousMoveTo(12.34)
+        self.assertEqual(betain.getPosition(), 12.34)
+
+    def mode(self, mode, alpha=0, gamma=0, betain=0, betaout=0, phi=0, sig=0,
+             tau=0):
+        self.dc.hklmode(mode)
+        self.dc.setpar('alpha', alpha)
+        self.dc.setpar('gamma', gamma)
+        self.dc.setpar('betain', betain)
+        self.dc.setpar('betaout', betaout)
+        self.dc.setpar('phi', phi)
+        self.dc.sigtau(sig, tau)
+
+    def test1(self):
+        self.mode(1)
+        self.hkl([.7, .9, 1.3])
+        aneq_((0., 27.3557, 0., 13.6779, 37.7746, 53.9654), self.sixc(), 4)
+        print self.hkl
+        print self.hklverbose
+
+    def test2(self):
+        self.mode(1, alpha=5, gamma=0)
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 26.9296, 0., 8.4916, 27.2563, 59.5855), self.sixc(), 4)
+
+    def test3(self):
+        self.mode(1, alpha=5, gamma=10)
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 22.9649, 10., 42.2204, 4.9721, 23.0655), self.sixc(), 4)
+
+    def test4(self):
+        self.mode(2, alpha=5, gamma=10, betain=4)
+
+        self.hkl([.7, .9, 1.3])
+        aneq_((5, 22.9649, 10., -11.8850, 4.7799, 80.4416),
+              self.sixc(), 4, note="[alpha, delta, gamma, omega, chi, phi")
+
+    def test5(self):
+        self.mode(1, alpha=5, gamma=10, sig=-1.3500, tau=-106)
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 22.9649, 10., 30.6586, 4.5295, 35.4036), self.sixc(), 4)
+
+    def test6(self):
+        self.mode(2, alpha=5, gamma=10, sig=-1.3500, tau=-106, betain=6)
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 22.9649, 10., 2.2388, 4.3898, 65.4395), self.sixc(), 4)
+
+    def test7(self):
+        self.mode(3, alpha=5, gamma=10, sig=-1.3500, tau=-106, betaout=7)
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 22.9649, 10., 43.4628, 5.0387, 21.7292), self.sixc(), 4)
+
+    def test7a(self):
+        self.mode(5, phi=10)  # Fix phi
+        self.hkl([.7, .9, 1.3])
+
+    def test8(self):
+        #8
+        self.mode(10, gamma=10, sig=-1.35, tau=-106)  # 5cgBeq
+        self.hkl([.7, .9, 1.3])
+        aneq_((6.1937, 22.1343, 10., 46.9523, 1.5102, 18.8112), self.sixc(), 3)
+
+    def test9(self):
+        self.mode(13, alpha=5, gamma=10, sig=-1.35, tau=-106)  # 5cgBeq
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 22.2183, 11.1054, 65.8276, 2.5180, -0.0749), self.sixc(), 4)
+
+    def test10(self):
+        self.mode(20, sig=-1.35, tau=-106)  # 6czBeq
+        self.hkl([.7, .9, 1.3])
+        aneq_((8.1693, 22.0156, 8.1693, -40.2188, 1.35, 106.), self.sixc(), 4)
+
+    def test11(self):
+        self.mode(21, betain=8, sig=-1.35, tau=-106)  # 6czBin
+        self.hkl([.7, .9, 1.3])
+        aneq_((8., 22.0156, 8.3386, -40.0939, 1.3500, 106.), self.sixc(), 4)
+
+    def test12(self):
+        self.mode(22, betaout=1, sig=-1.35, tau=-106)  # 6czBin
+        self.hkl([.7, .9, 1.3])
+        aneq_((15.4706, 22.0994, 1., -45.5521, 1.3500, 106.), self.sixc(), 4)
+
+
+class ZAxisGammaOnBaseTest(TestSixcBase):
+
+    def setup_method(self):
+        TestSixcBase.createDiffcalcAndScannables(self, SixCircleGeometry)
+        self.hklverbose = Hkl('hkl', self.sixc, self.dc, ('Bout'))
+        self.orient()
+
+    def orient(self):
+        self.dc.newub('From DDIF')
+        self.dc.setlat('cubic', 1, 1, 1)
+        self.en(12.39842 / 1)
+        self.dc.setu([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        self.dc.hklmode(20)  # zaxis, bisecting
+        self.dc.sigtau(0, 0)
+
+    def checkHKL(self, hkl, adgocp=None, betaout=None, nu=None):
+        self.hklverbose.asynchronousMoveTo(hkl)
+        aneq_(self.sixc(), list(adgocp), 3)
+        aneq_(self.hklverbose(), (hkl[0], hkl[1], hkl[2], betaout), 3)
+
+    def testHKL_001(self):
+        self.checkHKL([0, 0.0000001, 1], [30, 0, 60, 90, 0, 0], betaout=30, nu=0)
+
+    def testHKL_010(self):
+        self.checkHKL([0, 1, 0], [0, 60, 0, 120, 0, 0], betaout=0, nu=0)
+
+    def testHKL_011(self):
+        self.checkHKL([0, 1, 1], [30, 54.7356, 90, 125.2644, 0, 0],
+                      betaout=30, nu=-54.7356)
+
+    def testHKL_100(self):
+        self.checkHKL([1, 0, 0], [0, 60, 0, 30, 0, 0], betaout=0, nu=0)
+
+    def testHKL_101(self):
+        self.checkHKL([1, 0, 1], [30, 54.7356, 90, 35.2644, 0, 0],
+                      betaout=30, nu=-54.7356)
+
+    def testHKL_110(self):
+        #TODO: Modify test to ask that in this case gamma is left unmoved
+        self.checkHKL([1, 1, 0], [0, 90, 0, 90, 0, 0], betaout=0, nu=0)
+
+    def testHKL_1_1_0001(self):
+        self.checkHKL([1, 1, .0001], [0.0029, 89.9971, 90.0058, 90., 0, 0],
+                      betaout=0.0029, nu=89.9971)
+
+    def testHKL_111(self):
+        self.checkHKL([1, 1, 1], [30, 54.7356, 150, 99.7356, 0, 0],
+                      betaout=30, nu=54.7356)
+
+    def testHKL_11_0_0(self):
+        self.checkHKL([1.1, 0, 0], [0, 66.7340, 0., 33.3670, 0, 0],
+                      betaout=0, nu=0)
+
+    def testHKL_09_0_0(self):
+        self.checkHKL([.9, 0, 0], [0, 53.4874, 0, 26.7437, 0, 0],
+                      betaout=0, nu=0)
+
+    def testHKL_07_08_08(self):
+        self.checkHKL([.7, .8, .8], [23.5782, 59.9980, 76.7037, 84.2591, 0, 0],
+                      betaout=23.5782, nu=-49.1014)
+
+    def testHKL_07_08_09(self):
+        self.checkHKL([.7, .8, .9], [26.7437, 58.6754, 86.6919, 85.3391, 0, 0],
+                      betaout=26.7437, nu=-55.8910)
+
+    def testHKL_07_08_1(self):
+        self.checkHKL([.7, .8, 1], [30, 57.0626, 96.8659, 86.6739, 0, 0],
+                      betaout=30, nu=-63.0210)
+
+
+class ZAxisGammaOnBaseIncludingNuRotationTest(ZAxisGammaOnBaseTest):
+
+    def setup_method(self):
+        ZAxisGammaOnBaseTest.setup_method(self)
+        self.nu = DummyPD('nu')
+        self.sixc.slaveScannableDriver = NuDriverForSixCirclePlugin(self.nu)
+
+
+class SixcGammaOnBaseTest(TestSixcBase):
+
+    def setup_method(self):
+        TestSixcBase.createDiffcalcAndScannables(self, SixCircleGeometry)
+        self.hklverbose = Hkl('hkl', self.sixc, self.dc, ('Bout'))
+        self.orient()
+
+    def orient(self):
+        self.dc.newub('From DDIF')
+        self.dc.setlat('cubic', 1, 1, 1)
+        self.en(12.39842 / 1)
+        self.dc.setu([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        self.dc.sigtau(0, 0)
+
+    def testToFigureOut101and011(self):
+        self.hkl([1, 0, 1])
+        print "101: ", self.sixc()
+        self.hkl([0, 1, 1])
+        print "011: ", self.sixc()
+        print "**"
+
+    def testOrientation(self):
+        self.dc.newub('cubic')
+        self.dc.setlat('cubic', 1, 1, 1)
+        self.en(39842 / 1)
+        self.dc.sigtau(0, 0)
+        self.sixc([0, 90, 0, 45, 45, 0])
+        self.dc.addref([1, 0, 1])
+        self.sixc([0, 90, 0, 45, 45, 90])
+        self.dc.addref([0, 1, 1])
+        self.dc.checkub()
+        res = self.dc.ubcalc.U
+        des = matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        mneq_(res, des, 4)
+#         print "***"
+#         self.dc.dc()
+        print "***"
+        self.dc.showref()
+        print "***"
+        self.dc.hklmode()
+        print "***"
+
+
+class FiveCircleTest(object):
+
+    def setup_method(self):
+        self.en = DummyPD('en')
+        dummy = createDummyAxes(['alpha', 'delta', 'omega', 'chi', 'phi'])
+        group = ScannableGroup('fivecgrp', dummy)
+        self.fivec = DiffractometerScannableGroup('fivec', None, group)
+        
+        settings.hardware = ScannableHardwareAdapter(self.fivec, self.en)
+        settings.geometry = Fivec()
+        settings.ubcalc_persister = UbCalculationNonPersister()
+        from diffcalc.dc import dcvlieg as dc
+        reload(dc)
+        self.dc = dc
+        
+        self.fivec.diffcalc = self.dc
+        self.hkl = Hkl('hkl', self.fivec, self.dc)
+        self.hklverbose = Hkl('hkl', self.fivec, self.dc,
+                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
+        self.orient()
+
+    def orient(self):
+        self.dc.newub('b16_270608')
+        self.dc.setlat('xtal', 3.8401, 3.8401, 5.43072)
+        self.en(12.39842 / 1.24)
+        self.fivec([5.000, 22.790, 1.552, 22.400, 14.255])
+        self.dc.addref([1, 0, 1.0628])
+        self.fivec([5.000, 22.790, 4.575, 24.275, 101.320])
+        self.dc.addref([0, 1, 1.0628])
+        self.dc.checkub()
+
+    def testSetGammaFails(self):
+        self.assertRaises(
+            DiffcalcException, self.dc.setpar, 'gamma', 9999)
+
+    def test1(self):
+        self.dc.hklmode(1)
+        self.dc.setpar('alpha', 0)
+        self.hkl([.7, .9, 1.3])
+        aneq_((0., 27.3557, 13.6779, 37.7746, 53.9654), self.fivec(), 4)
+
+    def test2(self):
+        self.dc.hklmode(1)
+        self.dc.setpar('alpha', 5)
+        self.hkl([.7, .9, 1.3])
+        aneq_((5., 26.9296, 8.4916, 27.2563, 59.5855), self.fivec(), 4)
+
+
+class FourCircleTest(TestFourcBase):
+
+    def setup_method(self):
+        TestFourcBase.createDiffcalcAndScannables(self)
+        self.hklverbose = Hkl('hkl', self.fourc, self.dc,
+                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
+        self.orient()
+
+    def orient(self):
+        self.dc.newub('fromDiffcalcItself')
+        # This dataset generated by diffcalc code itself
+        # (not a proper test of code guts)
+        self.dc.setlat('xtal', 3.8401, 3.8401, 5.43072)
+        self.en(12.39842 / 1.24)
+        self.fourc([22.790, 1.552, 22.400, 14.255])
+        self.dc.addref([1, 0, 1.0628])
+        self.fourc([22.790, 4.575, 24.275, 101.320])
+        self.dc.addref([0, 1, 1.0628])
+        self.dc.checkub()
+
+    def testSetGammaFails(self):
+        self.assertRaises(
+            DiffcalcException, self.dc.setpar, 'gamma', 9999)
+
+    def test1(self):
+        self.dc.hklmode(1)
+        self.hkl([.7, .9, 1.3])
+        aneq_((27.3557325339904, 13.67786626699521, 23.481729970652825,
+               47.81491152277463), self.fourc(), 4)
+
+
+class FourCircleWithcubic(TestFourcBase):
+
+    def setup_method(self):
+        TestFourcBase.createDiffcalcAndScannables(self)
+        self.hklverbose = Hkl('hkl', self.fourc, self.dc,
+                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
+        self.orient()
+
+    def setUp3(self):
+        TestFourcBase.createDiffcalcAndScannables(self)
+        self.hklverbose = Hkl('hkl', self.fourc, self.dc,
+                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
+        self.orient()
+
+    def orient(self):
+        self.dc.newub('cubic')
+        # This dataset generated by diffcalc code itself
+        # (not a proper test of code guts)
+        self.dc.setlat('cube', 1, 1, 1, 90, 90, 90)
+        self.en(12.39842)
+        self.fourc([60, 30, 0, 0])
+        self.dc.addref([1, 0, 0])
+        self.fourc([60, 30, 90, 0])
+        self.dc.addref([0, 0, 1])
+        self.dc.checkub()
+
+    def testHkl100(self):
+        self.dc.hklmode(1)
+        self.dc.sigtau(0, 0)
+        self.hkl([1, 0, 0])
+        aneq_(self.fourc(), (60, -60, 0, 90), 4)
+        #dif gives
+        #h       k       l       alpha    delta    gamma    omega      chi  phi
+        #1.000   0.000   0.000   0.  60.   0.0000 -60.0000   0.0000  90.0000
+        #beta_in beta_out      rho      eta twotheta
+        #-0.0000   0.0000   0.0000   0.0000  60.0000
+
+    def testHkl001(self):
+        self.dc.hklmode(1)
+        self.dc.sigtau(0, 0)
+        self.hkl([0, 0, 1])
+        aneq_(self.fourc()[0:3], (60, 30, 90), 4)  # (phi is undetermined here)
+        #h       k       l        alpha    delta    gamma    omega      ch  phi
+        #0.000   0.000   1.000   0.0000  60.   0.  30.0000  90.0000  45.0000
+        #                          beta_in beta_out      rho      eta twotheta
+        #                          30.0000  30.0000  60.0000   0.5236  60.0000
+
+    def testHkl110(self):
+        self.dc.hklmode(1)
+        self.dc.sigtau(0, 0)
+        self.hkl([1, 1, 0])
+        # TODO: No check here!
+        #    h       k       l    alpha    delta    gamma    omega   chi    phi
+        #1.000   1.000   0.000   0.  90.   0.0000 135.0000   0.0000 -45.0000
+        #                          beta_in beta_out      rho      eta twotheta
+        #                           0.0000  -0.0000  -0.0000   0.0000  90.0000
+
+
+class FourCircleForI06Experiment(TestFourcBase):
+
+    def setup_method(self):
+        TestFourcBase.createDiffcalcAndScannables(self)
+        self.hklverbose = Hkl('hkl', self.fourc, self.dc,
+                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
+        self.orient()
+
+    def orient(self):
+        self.en(1.650)
+        self.dc.newub('cubic')
+        self.dc.setlat('xtal', 5.34, 5.34, 13.2, 90, 90, 90)
+        self.dc.setu([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        self.dc.hklmode(5)
+        self.dc.setpar('phi', -90)
+        self.dc.setcut('phi', -180)  # @UndefinedVariable
+
+    def testHkl001(self):
+        self.hkl([0, 0, 1])
+        aneq_(self.fourc(), [33.07329403295449, 16.536647016477247, 90., -90.],
+              note="[delta, omega, chi, phi]")
+
+#    def testHkl100(self):
+#        self.pos_hkl(1, 0, 0)
+#        aneq_(self.pos_fourc(),
+#              [89.42926563609406, 134.71463281804702, 90.0, -90.0],
+#              note="[delta, omega, chi, phi]")
+
+    def testHkl101(self):
+        self.hkl([1, 0, 1])
+        aneq_(self.fourc(), [98.74666191021282, 117.347760720783, 90., -90.],
+              note="[delta, omega, chi, phi]")
diff --git a/script/test/diffcalc (copy)/test/diffcalc/dc/you/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/dc/you/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/dc/you/test_fourcircle.py b/script/test/diffcalc (copy)/test/diffcalc/dc/you/test_fourcircle.py
new file mode 100644
index 0000000..e76a4a4
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/dc/you/test_fourcircle.py	
@@ -0,0 +1,72 @@
+from math import pi
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+from test.tools import mneq_, aneq_, assert_dict_almost_equal
+
+import diffcalc.util  # @UnusedImport
+from diffcalc.hardware import DummyHardwareAdapter
+from diffcalc.hkl.you.geometry import FourCircle
+from diffcalc.ub.persistence import UbCalculationNonPersister
+from diffcalc import settings
+
+
+diffcalc.util.DEBUG = True
+wl = 1
+en = 12.39842 / wl
+
+angles = [60, 30, 0, 0]
+param = {'tau': 90, 'psi': 90, 'beta': 0, 'alpha': 0, 'naz': 0, 'qaz': 90, 'theta': 30}
+
+
+dc = None
+def setup_module():
+    global dc
+    axes = 'delta', 'eta', 'chi', 'phi'
+    settings.hardware = DummyHardwareAdapter(axes)
+    settings.geometry = FourCircle()
+    settings.ubcalc_persister = UbCalculationNonPersister()
+    
+    from diffcalc.dc import dcyou as dc
+    reload(dc)
+    dc.newub('test')
+    dc.setlat('cubic', 1, 1, 1, 90, 90, 90)
+    dc.addref([1, 0, 0], [60, 30, 0, 0], en, 'ref1')
+    dc.addref([0, 1, 0], [60, 30, 0, 90], en, 'ref2')
+
+def test_orientation_phase():
+    # assumes reflections added were ideal (with no mis-mount)
+    dc.ub()
+    dc.checkub()
+    dc.showref()
+
+    U = matrix('1 0 0; 0 1 0; 0 0 1')
+    UB = U * 2 * pi
+    mneq_(dc._ub.ubcalc.U, U)
+    mneq_(dc._ub.ubcalc.UB, UB)
+   
+def test_angles_to_hkl_bypassing_hardware_plugin():
+    hkl_calc, param_calc = dc.angles_to_hkl(angles, en)
+    aneq_(hkl_calc, [1, 0, 0])
+    assert_dict_almost_equal(param_calc, param)
+    
+def test_hkl_to_angles_bypassing_hardware_plugin():
+    dc.con('a_eq_b')
+    h, k, l = [1, 0, 0]
+    angles_calc, param_calc = dc.hkl_to_angles(h, k, l, en)
+    aneq_(angles_calc, angles)
+    assert_dict_almost_equal(param_calc, param)
+    
+def test_angles_to_hkl():
+    hkl_calc, param_calc = dc.angles_to_hkl(angles, en)
+    aneq_(hkl_calc, [1, 0, 0])
+    assert_dict_almost_equal(param_calc, param)
+    
+def test_hkl_to_angles():
+    dc.con('a_eq_b')
+    h, k, l = [1, 0, 0]
+    angles_calc, param_calc = dc.hkl_to_angles(h, k, l, en)
+    aneq_(angles_calc, angles)
+    assert_dict_almost_equal(param_calc, param)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/dc/you/test_sixcircle.py b/script/test/diffcalc (copy)/test/diffcalc/dc/you/test_sixcircle.py
new file mode 100644
index 0000000..966d304
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/dc/you/test_sixcircle.py	
@@ -0,0 +1,95 @@
+
+from math import pi
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+from test.tools import mneq_, aneq_, dneq_
+
+import diffcalc.util  # @UnusedImport
+from diffcalc.hardware import DummyHardwareAdapter
+from diffcalc.hkl.you.geometry import SixCircle
+from diffcalc.ub.persistence import UbCalculationNonPersister
+from diffcalc.hkl.you.constraints import NUNAME
+from diffcalc import settings
+
+
+diffcalc.util.DEBUG = True
+wl = 1
+en = 12.39842 / wl
+
+angles = [0, 60, 0, 30, 0, 0]
+param = {'tau': 90, 'psi': 90, 'beta': 0, 'alpha': 0, 'naz': 0, 'qaz': 90, 'theta': 30}
+
+
+dc=None
+def setup_module():
+    global dc
+    axes = 'mu', 'delta', NUNAME, 'eta', 'chi', 'phi'
+    settings.hardware = DummyHardwareAdapter(axes)
+    settings.geometry = SixCircle()
+    settings.ubcalc_persister = UbCalculationNonPersister()
+    
+    from diffcalc.dc import dcyou as dc
+    reload(dc)
+
+    dc.newub('test')
+    dc.setlat('cubic', 1, 1, 1, 90, 90, 90)
+    dc.addref([1, 0, 0], [0, 60, 0, 30, 0, 0], en, 'ref1')
+    dc.addref([0, 1, 0], [0, 60, 0, 30, 0, 90], en, 'ref2')
+
+def test_orientation_phase():
+    # assumes reflections added were ideal (with no mis-mount)
+    dc.ub()
+    dc.checkub()
+    dc.showref()
+
+    U = matrix('1 0 0; 0 1 0; 0 0 1')
+    UB = U * 2 * pi
+    mneq_(dc._ub.ubcalc.U, U)
+    mneq_(dc._ub.ubcalc.UB, UB)
+       
+def test_angles_to_hkl_bypassing_hardware_plugin():
+    hkl_calc, param_calc = dc.angles_to_hkl(angles, en)
+    aneq_(hkl_calc, [1, 0, 0])
+    dneq_(param_calc, param)
+
+def test_hkl_to_angles_bypassing_hardware_plugin():
+    dc.con('a_eq_b')
+    dc.con('mu', 0)
+    dc.con(NUNAME, 0)
+
+    h, k, l = [1, 0, 0]
+    angles_calc, param_calc = dc.hkl_to_angles(h, k, l, en)
+    aneq_(angles_calc, angles)
+    dneq_(param_calc, param)
+
+def test_angles_to_hkl():
+    hkl_calc, param_calc = dc.angles_to_hkl(angles)
+    aneq_(hkl_calc, [1, 0, 0])
+    dneq_(param_calc, param)
+    
+def test_hkl_to_angles():
+    dc.con('a_eq_b')
+    dc.con('mu', 0)
+    dc.con(NUNAME, 0)
+
+    h, k, l = [1, 0, 0]
+    angles_calc, param_calc = dc.hkl_to_angles(h, k, l)
+    aneq_(angles_calc, angles)
+    dneq_(param_calc, param)
+    
+def test_allhkl():
+    diffcalc.util.DEBUG = True
+    dc.con('eta', 0, 'chi', 0, 'phi', 0)
+    dc.allhkl([.1, 0, .01], 1)
+    
+
+# def test_ub_help_visually(self):
+#     print "-" * 80 + "\nub:"
+#     print format_command_help(self.dc.ub.commands)
+# 
+# def test_hkl_help_visually(self):
+#     print "-" * 80 + "\nhkl:"
+#     print format_command_help(self.dc.hkl.commands)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/test_command.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/test_command.py
new file mode 100644
index 0000000..7ee6c65
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/test_command.py	
@@ -0,0 +1,138 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+import diffcalc.gdasupport.minigda.command
+from diffcalc.gdasupport.minigda.command import Pos, Scan, ScanDataPrinter
+from diffcalc.gdasupport.minigda.scannable import \
+    MultiInputExtraFieldsDummyScannable, SingleFieldDummyScannable
+
+
+class BadSingleFieldDummyScannable(SingleFieldDummyScannable):
+        def getPosition(self):
+            raise Exception("Problem")
+
+
+class NoneReturningSingleFieldDummyScannable(SingleFieldDummyScannable):
+        def getPosition(self):
+            return None
+
+
+class TestPos(object):
+
+    def setup_method(self):
+        self.dummyMainNamespace = namespace = {}
+        namespace['notAScannable'] = 3.124
+        namespace['scnA'] = SingleFieldDummyScannable('scnA')
+        namespace['scnB'] = SingleFieldDummyScannable('scnB')
+        namespace['scnC'] = SingleFieldDummyScannable('scnC')
+        namespace['scnD'] = SingleFieldDummyScannable('scnD')
+        namespace['scnNone'] = \
+            NoneReturningSingleFieldDummyScannable('scnNone')
+        namespace['scnBad'] = BadSingleFieldDummyScannable('scnBad')
+        
+        diffcalc.gdasupport.minigda.command.ROOT_NAMESPACE_DICT = \
+            self.dummyMainNamespace
+        self.pos = Pos()
+
+    def testPosReturningReportWithRead(self):
+        scnA = self.dummyMainNamespace['scnA']
+        assert self.pos.posReturningReport(scnA) == 'scnA:      0.0000'
+
+    def testPosReturningReportWithMove(self):
+        scnA = self.dummyMainNamespace['scnA']
+        assert self.pos.posReturningReport(scnA, 1.123) == 'scnA:      1.1230'
+
+    def test__call__(self):
+        scnA = self.dummyMainNamespace['scnA']
+        self.pos.__call__(scnA)
+        self.pos.__call__(scnA, 4.321)
+        print "*"
+        self.pos.__call__()
+        print "*"
+
+    def testPosReturningReportWithMultiFieldScannables(self):
+        scn = MultiInputExtraFieldsDummyScannable('mie', ['i1', 'i2'], ['e1'])
+        assert (self.pos.posReturningReport(scn) 
+                == 'mie:      i1: 0.0000 i2: 0.0000 e1: 100.0000 ')
+
+    def testPosReturningReportWithBadScannable(self):
+        scnBad = self.dummyMainNamespace['scnBad']
+        assert self.pos.posReturningReport(scnBad) == "scnBad:   Error: Problem"
+        assert (self.pos.posReturningReport(scnBad, 4.321)
+                 == "scnBad:   Error: Problem")
+
+    def testPosReturningReportWithNoneReturningScannable(self):
+        scnNone = self.dummyMainNamespace['scnNone']
+        assert self.pos.posReturningReport(scnNone) == "scnNone:  ---"
+        assert self.pos.posReturningReport(scnNone, 4.321) == "scnNone:  ---"
+
+
+class TestScan(object):
+
+    def setup_method(self):
+        self.scan = Scan([ScanDataPrinter()])
+
+    def test__parseScanArgsIntoScannableArgGroups(self):
+        scnA = SingleFieldDummyScannable('scnA')
+        scnB = SingleFieldDummyScannable('scnB')
+        scnC = SingleFieldDummyScannable('scnC')
+        scnD = SingleFieldDummyScannable('scnD')
+
+        scanargs = (scnA, 1, 2, 3, scnB, [4, 5, 6], scnC, scnD, 1.123456)
+        r = self.scan._parseScanArgsIntoScannableArgGroups(scanargs)
+        result = [r[0].scannable, r[0].args, r[1].scannable, r[1].args,
+                  r[2].scannable, r[2].args, r[3].scannable, r[3].args]
+        desired = [scnA, [1, 2, 3], scnB, [[4, 5, 6], ], scnC, list(), scnD,
+                   [1.123456]]
+        assert result == desired
+
+    def test__reorderGroupsAccordingToLevel(self):
+        scn4 = SingleFieldDummyScannable('scn4')
+        scn4.setLevel(4)
+        scn5a = SingleFieldDummyScannable('scn5a')
+        scn5a.setLevel(5)
+        scn5b = SingleFieldDummyScannable('scn5b')
+        scn5b.setLevel(5)
+        scn6 = SingleFieldDummyScannable('scn6')
+        scn6.setLevel(6)
+
+        def t(scanargs):
+            groups = self.scan._parseScanArgsIntoScannableArgGroups(scanargs)
+            r = self.scan._reorderInnerGroupsAccordingToLevel(groups)
+            return [r[0].scannable, r[1].scannable, r[2].scannable,
+                    r[3].scannable]
+
+        assert (t((scn5a, 1, 2, 3, scn6, 1, scn5b, scn4))
+                == [scn5a, scn4, scn5b, scn6])
+        assert (t((scn5a, 1, 3, scn6, 1, scn5b, scn4))
+                == [scn4, scn5a, scn5b, scn6])
+
+    def test__Frange(self):
+        assert self.scan._frange(1, 1.3, .1) == [1.0, 1.1, 1.2, 1.3]
+
+    def test__Call__(self):
+        scn4 = SingleFieldDummyScannable('scn4')
+        scn4.setLevel(4)
+        scn5a = SingleFieldDummyScannable('scn5a')
+        scn5a.setLevel(5)
+        scn5b = SingleFieldDummyScannable('scn5b')
+        scn5b.setLevel(5)
+        scn6 = SingleFieldDummyScannable('scn6')
+        scn6.setLevel(6)
+        self.scan.__call__(scn5a, 1, 3, 1, scn6, 1, scn5b, scn4)
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/test_scannable.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/test_scannable.py
new file mode 100644
index 0000000..d2ff6eb
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/minigda/test_scannable.py	
@@ -0,0 +1,83 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+try:
+    from gdascripts.pd.dummy_pds import DummyPD  # @UnusedImport
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+from diffcalc.gdasupport.scannable.mock import MockMotor
+from diffcalc.gdasupport.minigda.scannable import \
+    SingleFieldDummyScannable
+from diffcalc.gdasupport.minigda.scannable import Scannable
+from diffcalc.gdasupport.scannable.base import ScannableGroup
+
+
+class TestScannable(object):
+
+    def setup_method(self):
+        self.scannable = Scannable()
+
+    def testSomethingUnrelated(self):
+        a = SingleFieldDummyScannable('a')
+        print isinstance(a, Scannable)
+
+
+def createDummyAxes(names):
+    result = []
+    for name in names:
+        result.append(DummyPD(name))
+    return result
+
+
+class TestScannableGroup(object):
+
+    def setup_method(self):
+        self.a = MockMotor('a')
+        self.b = MockMotor('bbb')
+        self.c = MockMotor('c')
+        self.sg = ScannableGroup('abc', (self.a, self.b, self.c))
+
+    def testInit(self):
+        assert list(self.sg.getInputNames()) == ['a', 'bbb', 'c']
+        assert self.sg.getPosition() == [0.0, 0.0, 0.0]
+
+    def testAsynchronousMoveTo(self):
+        self.sg.asynchronousMoveTo([1, 2.0, 3])
+        assert self.sg.getPosition() == [1.0, 2.0, 3.0]
+
+    def testAsynchronousMoveToWithNones(self):
+        self.sg.asynchronousMoveTo([1.0, 2.0, 3.0])
+        self.sg.asynchronousMoveTo([None, None, 3.2])
+        assert self.sg.getPosition() == [1.0, 2.0, 3.2]
+
+    def testGetPosition(self):
+        # implicitely tested above
+        pass
+
+    def testIsBusy(self):
+        assert not self.sg.isBusy()
+        self.sg.asynchronousMoveTo([1.0, 2.0, 3.0])
+        assert self.sg.isBusy()
+        self.b.makeNotBusy()
+        assert self.sg.isBusy()
+        self.a.makeNotBusy()
+        self.c.makeNotBusy()
+        assert not self.sg.isBusy()
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/mockdiffcalc.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/mockdiffcalc.py
new file mode 100644
index 0000000..f6ae0a3
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/mockdiffcalc.py	
@@ -0,0 +1,55 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+class MockParameterManager:
+
+    def __init__(self):
+        self.params = {}
+
+    def set_constraint(self, name, value):
+        self.params[name] = value
+
+    def get_constraint(self, name):
+        return self.params[name]
+
+
+class MockDiffcalc:
+
+    def __init__(self, numberAngles):
+        self.numberAngles = numberAngles
+        self.parameter_manager = MockParameterManager()
+
+    def hkl_to_angles(self, h, k, l):
+        params = {}
+        params['theta'] = 1.
+        params['2theta'] = 12.
+        params['Bin'] = 123.
+        params['Bout'] = 1234.
+        params['azimuth'] = 12345.
+        return ([h] * self.numberAngles, params)
+
+    def angles_to_hkl(self, pos):
+        if len(pos) != self.numberAngles: raise ValueError
+        params = {}
+        params['theta'] = 1.
+        params['2theta'] = 12.
+        params['Bin'] = 123.
+        params['Bout'] = 1234.
+        params['azimuth'] = 12345.
+        return ([pos[0]] * 3, params)
+
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_diffractometer.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_diffractometer.py
new file mode 100644
index 0000000..9e3a4c3
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_diffractometer.py	
@@ -0,0 +1,169 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+from mock import Mock
+
+from diffcalc.gdasupport.scannable.slave_driver import SlaveScannableDriver
+from diffcalc.gdasupport.scannable.diffractometer import \
+    DiffractometerScannableGroup
+from diffcalc.gdasupport.scannable.mock import MockMotor
+from test.diffcalc.gdasupport.scannable.mockdiffcalc import MockDiffcalc
+try:
+    from gdascripts.pd.dummy_pds import DummyPD  # @UnusedImport
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+try:
+    from gda.device.scannable.scannablegroup import ScannableGroup
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import ScannableGroup
+
+
+def createDummyAxes(names):
+    result = []
+    for name in names:
+        result.append(DummyPD(name))
+    return result
+
+
+class MockSlaveScannableDriver(object):
+
+    def __init__(self):
+        self.busy = False
+        self.lastPosition = None
+
+    def isBusy(self):
+        return self.busy
+
+    def triggerAsynchronousMove(self, position):
+        self.lastPosition = position
+
+    def getPositions(self):
+        return 90, 91
+
+
+class TestDiffractometerScannableGroup(object):
+
+    def setup_method(self):
+        self.a = MockMotor()
+        self.b = MockMotor()
+        self.c = MockMotor()
+        self.d = MockMotor()
+        self.e = MockMotor()
+        self.f = MockMotor()
+        self.grp = ScannableGroup(
+            'grp', [self.a, self.b, self.c, self.d, self.e, self.f])
+        self.grp.configure()
+        self.sg = DiffractometerScannableGroup(
+            'sixc', MockDiffcalc(6), self.grp)
+
+    def testInit(self):
+        assert list(self.sg.getPosition()) == [0., 0., 0., 0., 0., 0.]
+
+    def testAsynchronousMoveTo(self):
+        self.sg.asynchronousMoveTo([1, 2.0, 3, 4, 5, 6])
+        assert list(self.sg.getPosition()) == [1., 2., 3., 4., 5., 6.]
+
+    def testAsynchronousMoveToWithNones(self):
+        self.sg.asynchronousMoveTo([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        self.sg.asynchronousMoveTo([None, None, 3.2, None, 5.2, None])
+        assert list(self.sg.getPosition()) == [1., 2., 3.2, 4., 5.2, 6.]
+
+    def testGetPosition(self):
+        #implicitely tested above
+        pass
+
+    def testWhereMoveTo(self):
+        # just check for exceptions
+        print self.sg.simulateMoveTo((1.23, 2, 3, 4, 5, 6))
+
+    def testIsBusy(self):
+        assert not self.sg.isBusy()
+        self.sg.asynchronousMoveTo([1.0, 2.0, 3.0, 4, 5, 6])
+        assert self.sg.isBusy()
+        self.b.makeNotBusy()
+        assert self.sg.isBusy()
+        self.a.makeNotBusy()
+        self.c.makeNotBusy()
+        self.d.makeNotBusy()
+        self.e.makeNotBusy()
+        self.f.makeNotBusy()
+        assert not self.sg.isBusy()
+
+    def testRepr(self):
+        print self.sg.__repr__()
+
+
+class TestDiffractometerScannableGroupWithSlave(
+    TestDiffractometerScannableGroup):
+
+    def setup_method(self):
+        TestDiffractometerScannableGroup.setup_method(self)
+        self.mock_driver = Mock(spec=SlaveScannableDriver)
+        self.mock_driver.getPositions.return_value = 90, 91
+        self.mock_driver.isBusy.return_value = False
+        self.mock_driver.getScannableNames.return_value = 'a', 'b'
+
+        self.sg.slave_driver = self.mock_driver
+
+    def test__init__(self):
+        sg = DiffractometerScannableGroup(
+            'sixc', MockDiffcalc(6), self.grp, self.mock_driver)
+        assert sg.slave_driver == self.mock_driver
+
+    def testAsynchronousMoveToWithNones(self):
+        self.sg.asynchronousMoveTo([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        self.sg.asynchronousMoveTo([None, None, 3.2, None, 5.2, None])
+        assert list(self.sg.getPosition()) == [1., 2., 3.2, 4., 5.2, 6., 90, 91]
+        self.mock_driver.triggerAsynchronousMove.assert_called_with(
+            [None, None, 3.2, None, 5.2, None])
+
+    def testIsBusyWithSlave(self):
+        self.mock_driver.isBusy.return_value = True
+        assert self.sg.isBusy()
+
+    ### overridden
+
+    def testInit(self):
+        assert list(self.sg.getPosition()) == [0., 0., 0., 0., 0., 0., 90, 91]
+
+    def testAsynchronousMoveTo(self):
+        self.sg.asynchronousMoveTo([1, 2.0, 3, 4, 5, 6])
+        assert list(self.sg.getPosition()) == [1., 2., 3., 4., 5., 6., 90, 91]
+
+
+class TestDiffractometerScannableGroupWithFailingAngleCalculator(object):
+
+    def setup_method(self):
+        class BadMockAngleCalculator:
+            def angles_to_hkl(self, pos):
+                raise Exception("Problem")
+        dummy = createDummyAxes(['alpha', 'delta', 'gamma', 'omega', 'chi',
+                                 'phi'])
+        self.group = ScannableGroup('grp', dummy)
+        self.group.configure()
+        self.sg = DiffractometerScannableGroup(
+            'sixc', BadMockAngleCalculator(), self.group)
+
+    def testGetPosition(self):
+        self.sg.getPosition()
+
+    def testSimulateMoveTo(self):
+        assert (self.sg.simulateMoveTo([1., 2., 3., 4., 5., 6.])
+                == "Error: Problem")
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_hkl.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_hkl.py
new file mode 100644
index 0000000..4ec65cc
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_hkl.py	
@@ -0,0 +1,222 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import mock
+import nose
+import unittest
+
+from diffcalc.gdasupport.scannable.diffractometer import \
+    DiffractometerScannableGroup
+from diffcalc.gdasupport.scannable.hkl import Hkl
+from test.diffcalc.gdasupport.scannable.mockdiffcalc import MockDiffcalc
+import pytest
+try:
+    from gda.device.scannable.scannablegroup import ScannableGroup
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import ScannableGroup
+
+
+try:
+    from gdascripts.pd.dummy_pds import DummyPD  # @UnusedImport
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+
+def createDummyAxes(names):
+    result = []
+    for name in names:
+        result.append(DummyPD(name))
+    return result
+
+
+PARAM_DICT = {'theta': 1, '2theta': 12., 'Bin': 123., 'Bout': 1234.,
+              'azimuth': 12345}
+
+
+class Popper:
+
+    def __init__(self, *items):
+        self.items = list(items)
+
+    def __call__(self, *args):
+        return self.items.pop(0)
+
+
+class TestHkl(object):
+
+    def setup_method(self):
+        self.mock_dc_module = mock.Mock()
+        self.mockSixc = mock.Mock(spec=DiffractometerScannableGroup)
+        self.hkl = Hkl('hkl', self.mockSixc, self.mock_dc_module)
+
+    def testInit(self):
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 2, 3], PARAM_DICT)
+        assert self.hkl.getPosition() == [1, 2, 3]
+
+    def testAsynchronousMoveTo(self):
+        self.mock_dc_module.hkl_to_angles.return_value = ([6, 5, 4, 3, 2, 1],
+                                                       None)
+        self.hkl.asynchronousMoveTo([1, 0, 1])
+        self.mock_dc_module.hkl_to_angles.assert_called_with(1, 0, 1)
+        self.mockSixc.asynchronousMoveTo.assert_called_with([6, 5, 4, 3, 2, 1])
+
+    def testGetPosition(self):
+        self.mockSixc.getPosition.return_value = [6, 5, 4, 3, 2, 1]
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1], PARAM_DICT)
+        assert self.hkl.getPosition() == [1, 0, 1]
+        self.mock_dc_module.angles_to_hkl.assert_called_with([6, 5, 4, 3, 2, 1])
+
+    def testAsynchronousMoveToWithNonesOutsideScan(self):
+        self.mockSixc.getPosition.return_value = [6, 5, 4, 3, 2, 1]
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1],
+                                                       PARAM_DICT)
+        self.mock_dc_module.hkl_to_angles.return_value = ([12, 5, 4, 3, 2, 1],
+                                                       PARAM_DICT)  # <- 2,0,1
+
+        self.hkl.asynchronousMoveTo([2, 0, None])
+
+        self.mock_dc_module.angles_to_hkl.assert_called_with([6, 5, 4, 3, 2, 1])
+        self.mock_dc_module.hkl_to_angles.assert_called_with(2, 0, 1)
+        self.mockSixc.asynchronousMoveTo.assert_called_with(
+            [12, 5, 4, 3, 2, 1])
+
+    def testAsynchronousMoveToWithNonesInScan(self):
+
+        self.mockSixc.getPosition.return_value = [6, 5, 4, 3, 2, 1]
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1], PARAM_DICT)
+        self.hkl.atScanStart()
+        # should not be used:
+        self.mockSixc.getPosition.return_value = [6.1, 5.1, 4.1, 3.1, 2.1, 1.1]
+        self.mock_dc_module.hkl_to_angles.return_value = ([12, 5, 4, 3, 2, 1],
+                                                       PARAM_DICT)
+        self.hkl.asynchronousMoveTo([2, 0, None])
+        # atScanStart:
+        self.mock_dc_module.angles_to_hkl.assert_called_with([6, 5, 4, 3, 2, 1])
+        self.mock_dc_module.hkl_to_angles.assert_called_with(2, 0, 1)
+        self.mockSixc.asynchronousMoveTo.assert_called_with(
+            [12, 5, 4, 3, 2, 1])
+
+    def testAsynchronousMoveToWithNonesInScanAfterCommandFailure(self):
+        # should be forgotten:
+        self.mockSixc.getPosition.return_value = [6, 5, 4, 3, 2, 1]
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1], PARAM_DICT)
+        self.hkl.atScanStart()
+        self.hkl.atCommandFailure()
+
+        self.mockSixc.getPosition.return_value = [6.1, 5.1, 4.1, 3.1, 2.1, 1.1]
+        self.mock_dc_module.hkl_to_angles.return_value = (
+                [12.1, 5.1, 4.1, 3.1, 2.1, 1.1], PARAM_DICT)
+        self.hkl.asynchronousMoveTo([2, 0, None])
+
+        self.mock_dc_module.angles_to_hkl.assert_called_with(
+            [6.1, 5.1, 4.1, 3.1, 2.1, 1.1])
+        self.mock_dc_module.hkl_to_angles.assert_called_with(2, 0, 1)
+        self.mockSixc.asynchronousMoveTo.assert_called_with(
+            [12.1, 5.1, 4.1, 3.1, 2.1, 1.1])
+
+    def testAsynchronousMoveToWithNonesInScanAfterAtScanEnd(self):
+        self.mockSixc.getPosition.return_value = [6, 5, 4, 3, 2, 1]
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1], PARAM_DICT)
+        self.hkl.atScanStart()
+        self.hkl.atScanEnd()
+
+        self.mockSixc.getPosition.return_value = [6.1, 5.1, 4.1, 3.1, 2.1, 1.1]
+        self.mock_dc_module.hkl_to_angles.return_value = (
+            [12.1, 5.1, 4.1, 3.1, 2.1, 1.1], PARAM_DICT)
+        self.hkl.asynchronousMoveTo([2, 0, None])
+
+        self.mock_dc_module.angles_to_hkl.assert_called_with(
+            [6.1, 5.1, 4.1, 3.1, 2.1, 1.1])
+        self.mock_dc_module.hkl_to_angles.assert_called_with(2, 0, 1)
+        self.mockSixc.asynchronousMoveTo.assert_called_with(
+            [12.1, 5.1, 4.1, 3.1, 2.1, 1.1])
+
+    def testIsBusy(self):
+        self.mockSixc.isBusy.return_value = False
+        assert not self.hkl.isBusy()
+        self.mockSixc.isBusy.assert_called()
+
+    def testWaitWhileBusy(self):
+        self.hkl.waitWhileBusy()
+        self.mockSixc.waitWhileBusy.assert_called()
+
+    def testWhereMoveTo(self):
+        # just check for exceptions
+        self.mock_dc_module.hkl_to_angles.return_value = ([6, 5, 4, 3, 2, 1],
+                                                       PARAM_DICT)
+        self.mockSixc.getName.return_value = 'sixc'
+        self.mockSixc.getInputNames.return_value = ['alpha', 'delta', 'gamma',
+                                                    'omega', 'chi', 'phi']
+        print self.hkl.simulateMoveTo((1.23, 0, 0))
+
+    def testDisp(self):
+        print self.hkl.__repr__()
+
+
+class TestHklReturningVirtualangles(TestHkl):
+    def setup_method(self):
+        TestHkl.setup_method(self)
+        self.hkl = Hkl('hkl', self.mockSixc, self.mock_dc_module,
+                       ['theta', '2theta', 'Bin', 'Bout', 'azimuth'])
+
+    def testInit(self):
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1], PARAM_DICT)
+        assert self.hkl.getPosition() == [1, 0, 1, 1, 12, 123, 1234, 12345]
+
+    def testGetPosition(self):
+        self.mockSixc.getPosition.return_value = [6, 5, 4, 3, 2, 1]
+        self.mock_dc_module.angles_to_hkl.return_value = ([1, 0, 1], PARAM_DICT)
+        assert self.hkl.getPosition() == [1, 0, 1, 1, 12, 123, 1234, 12345]
+        self.mock_dc_module.angles_to_hkl.assert_called_with([6, 5, 4, 3, 2, 1])
+
+
+class TestHklWithFailingAngleCalculator(object):
+    def setup_method(self):
+        class BadMockAngleCalculator:
+            def angles_to_hkl(self, pos):
+                raise Exception("Problem in angles_to_hkl")
+
+        dummy = createDummyAxes(['alpha', 'delta', 'gamma', 'omega', 'chi',
+                                 'phi'])
+        self.group = ScannableGroup('grp', dummy)
+        self.SixCircleGammaOnArmGeometry = DiffractometerScannableGroup(
+            'SixCircleGammaOnArmGeometry', MockDiffcalc(6), self.group)
+        self.hkl = Hkl('hkl', self.SixCircleGammaOnArmGeometry,
+                       BadMockAngleCalculator())
+
+    def testGetPosition(self):
+        with pytest.raises(Exception):
+            self.hkl.getPosition(None)
+
+    def test__repr__(self):
+        assert self.hkl.__repr__() == "<hkl: Problem in angles_to_hkl>"
+
+    def test__str__(self):
+        assert self.hkl.__str__() == "<hkl: Problem in angles_to_hkl>"
+
+    def testComponentGetPosition(self):
+        with pytest.raises(Exception):
+            self.hkl.h.getPosition(None)
+
+    def testComponent__repr__(self):
+        raise nose.SkipTest()
+        assert self.hkl.h.__repr__() == "<h: Problem in angles_to_hkl>"
+
+    def testComponent__str__(self):
+        raise nose.SkipTest()
+        assert self.hkl.h.__str__() == "<h: Problem in angles_to_hkl>"
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_parameter.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_parameter.py
new file mode 100644
index 0000000..961d398
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_parameter.py	
@@ -0,0 +1,38 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+from diffcalc.gdasupport.scannable.parameter import \
+    DiffractionCalculatorParameter
+from test.diffcalc.gdasupport.scannable.mockdiffcalc import \
+    MockParameterManager
+
+
+class TestDiffractionCalculatorParameter(object):
+
+    def setup_method(self):
+        self.dcp = DiffractionCalculatorParameter('dcp', 'betain',
+                                                  MockParameterManager())
+
+    def testAsynchronousMoveToAndGetPosition(self):
+        self.dcp.asynchronousMoveTo(12.3)
+        assert self.dcp.getPosition() == 12.3
+
+    def testIsBusy(self):
+        assert not self.dcp.isBusy()
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_simulation.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_simulation.py
new file mode 100644
index 0000000..cfa0090
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_simulation.py	
@@ -0,0 +1,102 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi
+import unittest
+from pytest import approx
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.gdasupport.scannable.simulation import SimulatedCrystalCounter, \
+    Gaussian
+from diffcalc.hkl.vlieg.geometry import Fourc
+from diffcalc.util import nearlyEqual
+from test.tools import mneq_
+
+
+class MockScannable(object):
+    def __init__(self):
+        self.pos = None
+
+    def getPosition(self):
+        return self.pos
+
+
+class MockEquation(object):
+
+    def __call__(self, dh, dk, dl):
+        self.dHkl = dh, dk, dl
+        return 1
+
+
+class TestSimulatedCrystalCounter(object):
+
+    def setup_method(self):
+        self.diff = MockScannable()
+        self.wl = MockScannable()
+        self.wl.pos = 1.
+        self.eq = MockEquation()
+        self.scc = SimulatedCrystalCounter('det', self.diff, Fourc(), self.wl,
+                                           self.eq)
+
+    def testInit(self):
+        assert list(self.scc.getInputNames()) == ['det_count']
+        assert list(self.scc.getExtraNames()) == []
+        assert self.scc.chiMissmount == 0.
+        assert self.scc.phiMissmount == 0.
+
+    def testCalcUB(self):
+        UB = matrix([[2 * pi, 0, 0], [0, 2 * pi, 0], [0, 0, 2 * pi]])
+        mneq_(self.scc.UB, UB)
+
+    def testGetHkl(self):
+        self.diff.pos = [60, 30, 0, 0]
+        hkl = self.scc.getHkl()
+        assert hkl == approx((1, 0, 0))
+
+        self.diff.pos = [60, 31, 0, 0]
+        hkl = self.scc.getHkl()
+        assert hkl == approx((0.999847695156391, 0.017452406437283574, 0))
+
+    def testGetPosition(self):
+        self.diff.pos = [60, 30, 0, 0]
+        self.scc.asynchronousMoveTo(2)
+        count = self.scc.getPosition()
+        assert self.eq.dHkl == approx((0, 0, 0))
+        assert count == 2
+
+        self.diff.pos = [60, 31, 0, 0]
+        count = self.scc.getPosition()
+        dHkl = (0.999847695156391 - 1, .017452406437283574, 0)
+        assert self.eq.dHkl == approx(dHkl)
+        assert count == 2
+
+    def test__repr__(self):
+        self.diff.pos = [60, 30, 0, 0]
+        print self.scc.__repr__()
+
+
+class TestGaussianEquation(object):
+    def setup_method(self):
+        self.eq = Gaussian(1.)
+
+    def test__call__(self):
+        assert self.eq(0, 0, 0) == 0.3989422804014327
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_wavelength.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_wavelength.py
new file mode 100644
index 0000000..7d43d61
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/scannable/test_wavelength.py	
@@ -0,0 +1,40 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+from diffcalc.gdasupport.scannable.wavelength import Wavelength
+try:
+    from gdascripts.pd.dummy_pds import DummyPD
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+
+class TestWavelength(object):
+
+    def setup_method(self):
+        self.en = DummyPD('en')
+        self.wl = Wavelength('wl', self.en)
+
+    def testIt(self):
+        self.en.asynchronousMoveTo(12.39842)
+        assert self.wl.getPosition() == 1
+
+        self.wl.asynchronousMoveTo(1.)
+        assert self.wl.getPosition() == 1.
+        assert self.en.getPosition() == 12.39842
diff --git a/script/test/diffcalc (copy)/test/diffcalc/gdasupport/test_you.py b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/test_you.py
new file mode 100644
index 0000000..7ce6fa1
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/gdasupport/test_you.py	
@@ -0,0 +1,180 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi
+from nose.tools import eq_, raises  # @UnresolvedImport
+from nose.plugins.skip import Skip, SkipTest  # @UnresolvedImport
+from diffcalc.hardware import ScannableHardwareAdapter
+from diffcalc.gdasupport.minigda.scannable import SingleFieldDummyScannable,\
+    ScannableGroup
+from diffcalc.hkl.you.geometry import SixCircle
+from diffcalc.ub.persistence import UbCalculationNonPersister
+
+import diffcalc.util  # @UnusedImport
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+import diffcalc.gdasupport.minigda.command
+from test.tools import mneq_
+
+from diffcalc import settings
+import diffcalc.hkl.you.calc
+diffcalc.gdasupport.minigda.command.ROOT_NAMESPACE_DICT = globals()
+pos = diffcalc.gdasupport.minigda.command.Pos()
+
+en = SingleFieldDummyScannable('en')  # keV
+mu = SingleFieldDummyScannable('mu')
+delta = SingleFieldDummyScannable('delta')
+gam = SingleFieldDummyScannable('gam')
+eta = SingleFieldDummyScannable('eta')
+chi = SingleFieldDummyScannable('chi')
+phi = SingleFieldDummyScannable('phi')
+sixc_group = ScannableGroup('sixc', (mu, delta, gam, eta, chi, phi))
+
+ubcalc_no = 1
+
+you = None
+def setup_module():
+    global you
+    settings.hardware = ScannableHardwareAdapter(sixc_group, en)
+    settings.geometry = SixCircle()
+    settings.ubcalc_persister = UbCalculationNonPersister()
+    settings.axes_scannable_group = sixc_group
+    settings.energy_scannable = en
+    settings.ubcalc_strategy = diffcalc.hkl.you.calc.YouUbCalcStrategy()
+    settings.angles_to_hkl_function = diffcalc.hkl.you.calc.youAnglesToHkl
+
+    from diffcalc.gdasupport import you
+    reload(you)
+
+
+"""
+All the components used here are well tested. This integration test is
+mainly to get output for the manual, to help when tweaking the user
+interface, and to make sure it all works together.
+"""
+# 
+# PRINT_WITH_USER_SYNTAX = True
+# for name, obj in self.objects.iteritems():
+#     if inspect.ismethod(obj):
+#         globals()[name] = wrap_command_to_print_calls(
+#                               obj, PRINT_WITH_USER_SYNTAX)
+#     else:
+#         globals()[name] = obj
+# pos = wrap_command_to_print_calls(Pos(globals()), PRINT_WITH_USER_SYNTAX)
+
+
+def call_scannable(scn):
+    print '\n>>> %s' % scn.name
+    print scn.__str__()
+
+
+
+
+
+
+def test_help_visually():
+    print "\n>>> help ub"
+    help(you.ub)
+    print "\n>>> help hkl"
+    help(you.hkl)
+    print "\n>>> help newub"
+    help(you.newub)
+
+def test_axes():
+    call_scannable(you.sixc)  # @UndefinedVariable
+    call_scannable(phi)
+
+def test_with_no_ubcalc():
+    you.ub()
+    you.showref()
+    call_scannable(you.hkl)
+
+def _orient():
+    global ubcalc_no
+    pos(you.wl, 1)
+    call_scannable(en)  # like typing en (or en())
+    you.newub('test' + str(ubcalc_no))
+    ubcalc_no += 1
+    you.setlat('cubic', 1, 1, 1, 90, 90, 90)
+
+    you.c2th([1, 0, 0])
+    pos(you.sixc, [0, 60, 0, 30, 0, 0])  # @UndefinedVariable
+    you.addref([1, 0, 0], 'ref1')
+
+    you.c2th([0, 1, 0])
+    pos(phi, 90)
+    you.addref([0, 1, 0], 'ref2')
+
+def test__orientation_phase():
+    _orient()
+    you.ub()
+    you.checkub()
+    you.showref()
+
+    U = matrix('1 0 0; 0 1 0; 0 0 1')
+    UB = U * 2 * pi
+    mneq_(you.ubcalc.U, U)
+    mneq_(you.ubcalc.UB, UB)
+
+def test_hkl_read():
+    _orient()
+    call_scannable(you.hkl)
+
+def test_help_con():
+    help(you.con)
+
+def test_constraint_mgmt():
+    diffcalc.util.DEBUG = True
+    you.con()  # TODO: show constrained values underneath
+
+def test_hkl_move_no_constraints():
+    raise SkipTest()
+    _orient()
+    pos(you.hkl, [1, 0, 0])
+
+def test_hkl_move_no_values():
+    raise SkipTest()
+    _orient()
+    you.con(mu)
+    you.con(gam)
+    you.con('a_eq_b')
+    you.con('a_eq_b')
+    pos(you.hkl, [1, 0, 0])
+
+def test_hkl_move_okay():
+    _orient()
+    you.ub()
+    you.con(mu)
+    you.con(gam)
+    you.con('a_eq_b')
+    pos(you.mu_con, 0)
+    pos(you.gam_con, 0)  # TODO: Fails with qaz=90
+    pos(you.hkl, [1, 1, 0])  # TODO: prints DEGENERATE. necessary?
+    call_scannable(you.sixc)  # @UndefinedVariable
+
+@raises(TypeError)
+def test_usage_error_signature():
+    you.c2th('wrong arg', 'wrong arg')
+
+@raises(TypeError)
+def test_usage_error_inside():
+    you.setlat('wrong arg', 'wrong arg')
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_calc.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_calc.py
new file mode 100644
index 0000000..291f803
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_calc.py	
@@ -0,0 +1,253 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import random
+import unittest
+from math import pi
+from mock import Mock
+from test.tools import mneq_
+import pytest
+
+try:
+    from numpy import matrix
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix
+    from numjy.linalg import norm
+
+from diffcalc.hkl.vlieg.calc import VliegHklCalculator, \
+    _findOmegaAndChiToRotateHchiIntoQalpha, check
+from diffcalc.hkl.vlieg.geometry import createVliegMatrices
+from diffcalc.util import DiffcalcException
+from test.diffcalc import scenarios
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+def createMockUbcalc(UB):
+    ubcalc = Mock()
+    ubcalc.tau = 0
+    ubcalc.sigma = 0
+    ubcalc.UB = UB
+    ubcalc.n_phi = matrix([[0], [0], [1]])
+    return ubcalc
+
+
+def createMockHardwareMonitor():
+    hardware = Mock()
+    hardware.get_position.return_value = (0.0, 0.0, 0.0)
+    hardware.get_axes_names.return_value = 'madeup', 'alpha', 'gamma'
+    return hardware
+
+
+def createMockDiffractometerGeometry():
+    geometry = Mock()
+    geometry.parameter_fixed.return_value = False
+    geometry.supports_mode_group.return_value = True
+    geometry.fixed_parameters = {}
+    geometry.name = 'mock'
+    geometry.gamma_location = 'arm'
+    return geometry
+
+
+class TestVliegCoreMathBits(object):
+
+    def setup_method(self):
+        self.many = [-91, -90, -89, -46, -45, -44, -1,
+                     0, 1, 44, 45, 46, 89, 90, 91]
+        self.many = (self.many +
+                     map(lambda x: x + 180, self.many) +
+                     map(lambda x: x - 180, self.many))
+
+    def test_check(self):
+        check(True, 'Should not throw')
+        with pytest.raises(Exception):
+            check(False, 'string')
+        with pytest.raises(DiffcalcException):
+            check(False, DiffcalcException('dce'))
+
+        def acallable(toPrint=None):
+            if toPrint is None:
+                print "Not throwing exception"
+            else:
+                print toPrint
+
+        check(False, acallable)
+        check(False, acallable, 'this should be printed')
+
+    # TODO: Removed 2017-03-06, deprecated started code failing -- RobW.
+    def SKIP__findOmegaAndChiToRotateHchiIntoQalpha_WithIntegerValues(self):
+        for omega in self.many:
+            for chi in self.many:
+                print str(omega), ",", str(chi)
+                self.try__findOmegaAndChiToRotateHchiIntoQalpha(omega, chi)
+
+    def SKIP_findOmegaAndChiToRotateHchiIntoQalpha_WithRandomValues(self):
+        for _ in range(10):
+            for omega in self.many:
+                for chi in self.many:
+                    omega = omega + random.uniform(-.001, .001)
+                    chi = chi + random.uniform(-.001, .001)
+                    self.try__findOmegaAndChiToRotateHchiIntoQalpha(omega, chi)
+                    #print str(omega), ",", str(chi)
+
+    def test__findOmegaAndChiToRotateHchiIntoQalpha_WithTrickyOnes(self):
+        tricky_ones = [(-45., -180.), (45., -180.), (135., -180.), (2000, 0.),
+                       (225., 0.), (225., -180.), (-225., 0.), (-225., 0.),
+                       (-225., -180.), (-135., -180.), (89.998894, -44.999218)]
+        for omega, chi in tricky_ones:
+            self.try__findOmegaAndChiToRotateHchiIntoQalpha(omega, chi)
+
+    def try__findOmegaAndChiToRotateHchiIntoQalpha(self, omega, chi):
+        h_chi = matrix([[1], [1], [1]])
+        h_chi = h_chi * (1 / norm(h_chi))
+        [_, _, _, OMEGA, CHI, _] = createVliegMatrices(
+            None, None, None, omega * TORAD, chi * TORAD, None)
+        q_alpha = OMEGA * CHI * h_chi
+        try:
+            omega_calc, chi_calc = _findOmegaAndChiToRotateHchiIntoQalpha(
+                h_chi, q_alpha)
+        except ValueError, e:
+            raise ValueError(str(e) + "\n, resulting from test where omega:%f"
+                             " chi%f" % (self.omega, self.chi))
+        [_, _, _, OMEGA, CHI, _] = createVliegMatrices(
+            None, None, None, omega_calc, chi_calc, None)
+        self.assertArraysNearlyEqual(OMEGA * CHI * h_chi, q_alpha, .000001,
+                                     "omega: %f chi:%f" % (omega, chi))
+
+    def assertArraysNearlyEqual(self, first, second, tolerance,
+                                contextString=''):
+        """
+        Fail if the norm of the difference between two arrays is greater than
+        the given tolerance.
+        """
+        diff = first - second
+        if norm(diff) >= tolerance:
+            raise self.failureException(
+                '\n%r !=\n %r\ncontext: %s' %
+                (first.tolist(), second.tolist(), contextString))
+
+
+class BaseTestHklCalculator():
+
+    def setSessionAndCalculation(self):
+        raise Exception("Abstract")
+
+    def setup_method(self):
+        self.ac = VliegHklCalculator(None, createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor())
+        self.ac.raiseExceptionsIfAnglesDoNotMapBackToHkl = True
+        self.setSessionAndCalculation()
+
+    def testAnglesToHkl(self):
+        mockUbcalc = createMockUbcalc(
+            matrix(self.sess.umatrix) * matrix(self.sess.bmatrix))
+
+        self.ac = VliegHklCalculator(mockUbcalc,
+                                     createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor())
+        self.ac.raiseExceptionsIfAnglesDoNotMapBackToHkl = True
+
+        # Check the two given reflections
+        (hklactual1, params) = self.ac.anglesToHkl(self.sess.ref1.pos,
+                                                   self.sess.ref1.wavelength)
+        del params
+        (hklactual2, params) = self.ac.anglesToHkl(self.sess.ref2.pos,
+                                                   self.sess.ref2.wavelength)
+        mneq_(matrix([hklactual1]), matrix([self.sess.ref1calchkl]), 3)
+        mneq_(matrix([hklactual2]), matrix([self.sess.ref2calchkl]), 3)
+
+        # ... znd in each calculation through the hkl/posiiont pairs
+        if self.calc:
+            for hkl, pos, param in zip(self.calc.hklList,
+                                       self.calc.posList,
+                                       self.calc.paramList):
+                (hkl_actual, params) = self.ac.anglesToHkl(pos,
+                                                        self.calc.wavelength)
+                note = ("wrong hkl calcualted for scenario.name=%s, "
+                        "calculation.tag=%s\n  expected hkl=(%f,%f,%f)\n"
+                        "calculated hkl=(%f,%f,%f)" %
+                        (self.sess.name, self.calc.tag, hkl[0], hkl[1], hkl[2],
+                         hkl_actual[0], hkl_actual[1], hkl_actual[2]))
+                mneq_(matrix([hkl_actual]), matrix([hkl]), 3, note=note)
+                print "***anglesToHkl***"
+                print "*** ", str(hkl), " ***"
+                print params
+                print param
+
+    def testHklToAngles(self):
+        if self.calc:
+            # Configure the angle calculator for this session scenario
+            UB = matrix(self.sess.umatrix) * matrix(self.sess.bmatrix)
+            mockUbcalc = createMockUbcalc(UB)
+            hw = createMockHardwareMonitor()
+            ac = VliegHklCalculator(mockUbcalc,
+                                    createMockDiffractometerGeometry(), hw)
+            ac.raiseExceptionsIfAnglesDoNotMapBackToHkl = True
+
+            ## configure the angle calculator for this calculation
+            ac.mode_selector.setModeByName(self.calc.modeToTest)
+
+            # Set fixed parameters
+            if self.calc.modeToTest in ('4cBeq', '4cFixedw'):
+
+                #ac.setParameter('alpha', self.calc.alpha )
+                ac.parameter_manager.setTrackParameter('alpha', True)
+                hw.get_position.return_value = 888, self.calc.alpha, 999
+                ac.parameter_manager.set_constraint('gamma', self.calc.gamma)
+
+            # Test each hkl/position pair
+            for idx in range(len(self.calc.hklList)):
+                hkl = self.calc.hklList[idx]
+                expectedpos = self.calc.posList[idx]
+                (pos, params) = ac.hklToAngles(hkl[0], hkl[1], hkl[2],
+                                               self.calc.wavelength)
+                note = ("wrong positions calculated for TestScenario=%s, "
+                        "AngleTestScenario=%s, hkl=(%f,%f,%f):\n"
+                        "  expected pos=%s;\n"
+                        "  returned pos=%s " %
+                        (self.sess.name, self.calc.tag, hkl[0], hkl[1], hkl[2],
+                         str(expectedpos), str(pos)))
+                assert pos.nearlyEquals(expectedpos, 0.01), note
+                print "*** hklToAngles ***"
+                print "*** ", str(hkl), " ***"
+                print params
+                try:
+                    print self.calc.paramList[idx]
+                except IndexError:  # Not always specified
+                    pass
+
+
+class TestVliegHklCalculatorSess1NoCalc(BaseTestHklCalculator):
+    def setSessionAndCalculation(self):
+        self.sess = scenarios.sessions()[0]
+        self.calc = None
+
+
+class TestVliegHklCalculatorSess2Calc0(BaseTestHklCalculator):
+    def setSessionAndCalculation(self):
+        self.sess = scenarios.sessions()[1]
+        self.calc = self.sess.calculations[0]
+
+
+class TestVliegHklCalculatorSess3Calc0(
+    BaseTestHklCalculator):
+    def setSessionAndCalculation(self):
+        self.sess = scenarios.sessions()[2]
+        self.calc = self.sess.calculations[0]
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_constraints.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_constraints.py
new file mode 100644
index 0000000..0ae5ba4
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_constraints.py	
@@ -0,0 +1,92 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+from diffcalc.hkl.vlieg.constraints import ModeSelector, VliegParameterManager
+from diffcalc.util import DiffcalcException
+from test.diffcalc.hkl.vlieg.test_calc import \
+    createMockHardwareMonitor, createMockDiffractometerGeometry
+import pytest
+
+
+class TestModeSelector(object):
+
+    def setup_method(self):
+
+        self.ms = ModeSelector(createMockDiffractometerGeometry(),
+                               parameterManager=None)
+        self.pm = VliegParameterManager(createMockDiffractometerGeometry(),
+                                        None, self.ms)
+        self.ms.setParameterManager(self.pm)
+
+    def testSetModeByIndex(self):
+        self.ms.setModeByIndex(0)
+        assert self.ms.getMode().name == '4cFixedw'
+        self.ms.setModeByIndex(1)
+        assert self.ms.getMode().name == '4cBeq'
+
+    def testGetMode(self):
+        # tested implicetely by testSetmode
+        pass
+
+    def testShowAvailableModes(self):
+        print self.ms.reportAvailableModes()
+
+
+class TestParameterManager(object):
+
+    def setup_method(self):
+        self.hw = createMockHardwareMonitor()
+        self.ms = ModeSelector(createMockDiffractometerGeometry())
+        self.pm = VliegParameterManager(createMockDiffractometerGeometry(),
+                                        self.hw, self.ms)
+
+    def testDefaultParameterValues(self):
+        assert self.pm.get_constraint('alpha') == 0
+        assert self.pm.get_constraint('gamma') == 0
+        with pytest.raises(DiffcalcException):
+            self.pm.get_constraint('not-a-parameter-name')
+
+    def testSetParameter(self):
+        self.pm.set_constraint('alpha', 10.1)
+        assert self.pm.get_constraint('alpha') == 10.1
+
+    def testSetTrackParameter_isParameterChecked(self):
+        assert not self.pm.isParameterTracked('alpha')
+        self.pm.set_constraint('alpha', 9)
+
+        self.pm.setTrackParameter('alpha', True)
+        assert self.pm.isParameterTracked('alpha') == True
+        with pytest.raises(DiffcalcException):
+            self.pm.set_constraint('alpha', 10)
+        self.hw.get_position.return_value = 888, 11, 999
+        assert self.pm.get_constraint('alpha') == 11
+
+        print self.pm.reportAllParameters()
+        print "**"
+        print self.ms.reportCurrentMode()
+        print self.pm.reportParametersUsedInCurrentMode()
+
+        self.pm.setTrackParameter('alpha', False)
+        assert not self.pm.isParameterTracked('alpha')
+        assert self.pm.get_constraint('alpha') == 11
+        self.hw.get_position.return_value = 888, 12, 999
+        assert self.pm.get_constraint('alpha') == 11
+        self.pm.set_constraint('alpha', 13)
+        assert self.pm.get_constraint('alpha') == 13
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_geometry.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_geometry.py
new file mode 100644
index 0000000..6eaf622
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_geometry.py	
@@ -0,0 +1,248 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import random
+import unittest
+from math import pi
+
+try:
+    from numpy import matrix
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix
+    from numjy.linalg import norm
+from test.tools import mneq_
+
+
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry, \
+    gammaOnArmToBase, gammaOnBaseToArm, SixCircleGeometry, Fivec, Fourc
+from diffcalc.hkl.vlieg.geometry import createVliegMatrices
+from diffcalc.hkl.vlieg.geometry import VliegPosition
+from diffcalc.util import nearlyEqual, radiansEquivilant as radeq
+
+
+random.seed()  # uses time
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+class TestSixCirclePlugin(object):
+
+    def setup_method(self):
+        self.geometry = SixCircleGeometry()
+
+    def testGetName(self):
+        assert self.geometry.name == "sixc"
+
+    def testPhysicalAnglesToInternalPosition(self):
+        pos = [0, 0, 0, 0, 0, 0]
+        expected = self.geometry.physical_angles_to_internal_position(pos)
+        assert VliegPosition(*pos) == expected
+
+    def testInternalPositionToPhysicalAngles(self):
+        pos = VliegPosition(0, 0, 0, 0, 0, 0)
+        result = self.geometry.internal_position_to_physical_angles(pos)
+        assert norm(matrix([pos.totuple()]) - matrix([result])) < 0.001
+
+    def testGammaOn(self):
+        assert self.geometry.gamma_location == 'base'
+
+    def testSupportsModeGroup(self):
+        assert self.geometry.supports_mode_group('fourc')
+        assert not self.geometry.supports_mode_group('made up mode')
+
+    def testGetFixedParameters(self):
+        self.geometry.fixed_parameters  # check for exceptions
+
+    def isParamaterUnchangable(self):
+        assert not self.geometry.isParamaterUnchangable('made up parameter')
+
+
+class TestSixCircleGammaOnArmGeometry(object):
+
+    def setup_method(self):
+        self.geometry = SixCircleGammaOnArmGeometry()
+
+    def testGetName(self):
+        assert self.geometry.name == "sixc_gamma_on_arm"
+
+    def testPhysicalAnglesToInternalPosition(self):
+        pos = [1, 2, 3, 4, 5, 6]
+        expected = self.geometry.physical_angles_to_internal_position(pos)
+        assert VliegPosition(*pos) == expected
+
+    def testInternalPositionToPhysicalAngles(self):
+        pos = VliegPosition(1, 2, 3, 4, 5, 6)
+        result = self.geometry.internal_position_to_physical_angles(pos)
+        mneq_(matrix([pos.totuple()]), matrix([result]), 4)
+
+    def testSupportsModeGroup(self):
+        assert self.geometry.supports_mode_group('fourc')
+        assert not self.geometry.supports_mode_group('made up mode')
+
+    def testGetFixedParameters(self):
+        self.geometry.fixed_parameters  # check for exceptions
+
+    def isParamaterUnchangable(self):
+        assert not self.geometry.isParamaterUnchangable('made up parameter')
+
+
+y_vector = matrix([[0], [1], [0]])
+
+TOLERANCE = 1e-5
+
+
+def armAnglesToLabVector(alpha, delta, gamma):
+    [ALPHA, DELTA, GAMMA, _, _, _] = createVliegMatrices(
+        alpha, delta, gamma, None, None, None)
+    return ALPHA * DELTA * GAMMA * y_vector
+
+
+def baseAnglesToLabVector(delta, gamma):
+    [_, DELTA, GAMMA, _, _, _] = createVliegMatrices(
+        None, delta, gamma, None, None, None)
+    return GAMMA * DELTA * y_vector
+
+
+def checkGammaOnArmToBase(alpha, deltaA, gammaA):
+        deltaB, gammaB = gammaOnArmToBase(deltaA, gammaA, alpha)
+
+        labA = armAnglesToLabVector(alpha, deltaA, gammaA)
+        labB = baseAnglesToLabVector(deltaB, gammaB)
+        if not nearlyEqual(labA, labB, TOLERANCE):
+            strLabA = ("[%f, %f, %f]" %
+                       (labA.get(0, 0), labA.get(1, 0), labA.get(2, 0)))
+            strLabB = ("[%f, %f, %f]" %
+                       (labB.get(0, 0), labB.get(1, 0), labB.get(2, 0)))
+            rep = ("alpha=%f, delta=%f, gamma=%f" %
+                   (alpha * TODEG, deltaB * TODEG, gammaB * TODEG))
+            raise AssertionError('\nArm-->Base ' + rep + '\n' +
+                "arm (delta, gamma) = (%f,%f) <==>\t labA = %s\n" %
+                (deltaA * TODEG, gammaA * TODEG, strLabA) +
+                "base(delta, gamma) = (%f,%f) <==>\t labB = %s\n" %
+                (deltaB * TODEG, gammaB * TODEG, strLabB))
+
+
+def checkBaseArmBaseReciprocity(alpha, delta_orig, gamma_orig):
+        (deltaB, gammaB) = (delta_orig, gamma_orig)
+        (deltaA, gammaA) = gammaOnBaseToArm(deltaB, gammaB, alpha)
+        (deltaB, gammaB) = gammaOnArmToBase(deltaA, gammaA, alpha)
+        if ((not radeq(deltaB, delta_orig, TOLERANCE)) or
+            (not radeq(gammaB, gamma_orig, TOLERANCE))):
+            s = "\nBase-Arm-Base reciprocity\n"
+            s += 'alpha=%f\n' % (alpha * TODEG,)
+            s += ('   (deltaB, gammaB) = (%f, %f)\n' %
+                  (delta_orig * TODEG, gamma_orig * TODEG))
+            s += (' ->(deltaA, gammaA) = (%f, %f)\n' %
+                  (deltaA * TODEG, gammaA * TODEG))
+            s += (' ->(deltaB, gammaB) = (%f, %f)\n' %
+                  (deltaB * TODEG, gammaB * TODEG))
+            raise AssertionError(s)
+
+
+def checkArmBaseArmReciprocity(alpha, delta_orig, gamma_orig):
+    (deltaA, gammaA) = (delta_orig, gamma_orig)
+    (deltaB, gammaB) = gammaOnArmToBase(deltaA, gammaA, alpha)
+    (deltaA, gammaA) = gammaOnBaseToArm(deltaB, gammaB, alpha)
+    if ((not radeq(deltaA, delta_orig, TOLERANCE)) or
+        (not radeq(gammaA, gamma_orig, TOLERANCE))):
+        s = "\nArm-Base-Arm reciprocity\n"
+        s += "alpha=%f\n" % (alpha * TODEG,)
+        s += ("   (deltaA, gammaA) = (%f, %f)\n" %
+              (delta_orig * TODEG, gamma_orig * TODEG))
+        s += (" ->(deltaB, gammaB) = (%f, %f)\n" %
+              (deltaB * TODEG, gammaB * TODEG))
+        s += (" ->(deltaA, gammaA) = (%f, %f)\n" %
+              (deltaA * TODEG, gammaA * TODEG))
+        raise AssertionError(s)
+
+
+def test_generator_for_cases():
+    for alpha in [-89.9, -45, -1, 0, 1, 45, 89.9]:
+        for gamma in [-89.9, -46, -45, -44, -1, 0, 1, 44, 45, 46, 89.9]:
+            for delta in [-179.9, -135, -91, -89.9, -89, -46, -45, -44, -1, 0,
+                          1, 44, 45, 46, 89, 89.9, 91, 135, 179.9]:
+                yield (checkGammaOnArmToBase, alpha * TORAD, delta * TORAD,
+                       gamma * TORAD)
+                yield (checkArmBaseArmReciprocity, alpha * TORAD,
+                       delta * TORAD, gamma * TORAD)
+
+
+class TestFiveCirclePlugin(object):
+
+    def setup_method(self):
+        self.geometry = Fivec()
+
+    def testGetName(self):
+        assert self.geometry.name == "fivec"
+
+    def testPhysicalAnglesToInternalPosition(self):
+        expected = self.geometry.physical_angles_to_internal_position(
+            (1, 2, 4, 5, 6))
+        assert VliegPosition(1, 2, 0, 4, 5, 6) == expected
+
+    def testInternalPositionToPhysicalAngles(self):
+        result = self.geometry.internal_position_to_physical_angles(
+            VliegPosition(1, 2, 0, 4, 5, 6))
+        assert (norm(matrix([[1, 2, 4, 5, 6]]) - (matrix([list(result)])))
+                < 0.001)
+
+    def testSupportsModeGroup(self):
+        assert self.geometry.supports_mode_group('fourc')
+        assert not self.geometry.supports_mode_group('fivecFixedAlpha')
+        assert self.geometry.supports_mode_group('fivecFixedGamma')
+
+    def testGetFixedParameters(self):
+        self.geometry.fixed_parameters  # check for exceptions
+
+    def testisParamaterFixed(self):
+        assert not self.geometry.parameter_fixed('made up parameter')
+        assert self.geometry.parameter_fixed('gamma')
+
+
+class TestFourCirclePlugin(object):
+
+    def setup_method(self):
+        self.geometry = Fourc()
+
+    def testGetName(self):
+        assert self.geometry.name == "fourc"
+
+    def testPhysicalAnglesToInternalPosition(self):
+        expected = self.geometry.physical_angles_to_internal_position((2, 4, 5, 6))
+        assert VliegPosition(0, 2, 0, 4, 5, 6) == expected
+
+    def testInternalPositionToPhysicalAngles(self):
+        result = self.geometry.internal_position_to_physical_angles(
+            VliegPosition(0, 2, 0, 4, 5, 6))
+        assert (norm(matrix([[2, 4, 5, 6]]) - matrix([list(result)]))
+                     < 0.001)
+
+    def testSupportsModeGroup(self):
+        assert self.geometry.supports_mode_group('fourc')
+        assert not self.geometry.supports_mode_group('fivecFixedAlpha')
+        assert not self.geometry.supports_mode_group('fivecFixedGamma')
+
+    def testGetFixedParameters(self):
+        self.geometry.fixed_parameters  # check for exceptions
+
+    def testisParamaterFixed(self):
+        assert not self.geometry.parameter_fixed('made up parameter')
+        assert self.geometry.parameter_fixed('gamma')
+        assert self.geometry.parameter_fixed('alpha')
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_hkl.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_hkl.py
new file mode 100644
index 0000000..4aa6d9c
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_hkl.py	
@@ -0,0 +1,84 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+from mock import Mock
+
+import diffcalc.util  # @UnusedImport to overide raw_input
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry
+from diffcalc.hardware import DummyHardwareAdapter
+from diffcalc.util import MockRawInput
+from diffcalc.hkl.vlieg.calc import VliegHklCalculator
+from diffcalc.ub.calc import UBCalculation
+from diffcalc.ub.persistence import UbCalculationNonPersister
+import pytest
+
+try:
+    from gdascripts.pd.dummy_pds import DummyPD  # @UnusedImport
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+
+def prepareRawInput(listOfStrings):
+    diffcalc.util.raw_input = MockRawInput(listOfStrings)
+
+prepareRawInput([])
+
+
+class TestHklCommands(object):
+
+    def setup_method(self):
+        self.geometry = SixCircleGammaOnArmGeometry()
+        dummy = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
+        self.hardware = DummyHardwareAdapter(dummy)
+        self.mock_ubcalc = Mock(spec=UBCalculation)
+        self.hklcalc = VliegHklCalculator(self.mock_ubcalc, self.geometry,
+                                          self.hardware, True)
+        from diffcalc import settings
+        settings.hardware = self.hardware
+        settings.geometry = self.geometry
+        settings.ubcalc_persister = UbCalculationNonPersister()
+        
+        from diffcalc.hkl.vlieg import hkl
+        reload(hkl)
+        hkl.hklcalc = self.hklcalc
+        self.hkl = hkl
+        prepareRawInput([])
+
+    def testHklmode(self):
+        with pytest.raises(TypeError):
+            self.hkl.hklmode(1, 2)
+        with pytest.raises(ValueError):
+            self.hkl.hklmode('unwanted_string')
+        print self.hkl.hklmode()
+        print self.hkl.hklmode(1)
+
+    def testSetWithString(self):
+        self.hkl.setpar()
+        self.hkl.setpar('alpha')
+        self.hkl.setpar('alpha', 1)
+        self.hkl.setpar('alpha', 1.1)
+        pm = self.hkl.hklcalc.parameter_manager
+        assert pm.get_constraint('alpha') == 1.1
+
+    def testSetWithScannable(self):
+        alpha = DummyPD('alpha')
+        self.hkl.setpar(alpha, 1.1)
+        pm = self.hkl.hklcalc.parameter_manager
+        assert pm.get_constraint('alpha') == 1.1
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_transform.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_transform.py
new file mode 100644
index 0000000..d1c4265
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/vlieg/test_transform.py	
@@ -0,0 +1,463 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from nose.tools import eq_
+import unittest
+
+from mock import Mock
+
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry
+from diffcalc.hardware import DummyHardwareAdapter
+from diffcalc.hkl.vlieg.geometry import VliegPosition as P, \
+   VliegPosition as Pos
+from diffcalc.hkl.vlieg.transform import TransformA, TransformB, TransformC, \
+    transformsFromSector, TransformCommands, \
+    VliegTransformSelector, VliegPositionTransformer
+import diffcalc.util  # @UnusedImport
+import pytest
+
+
+class TestVliegPositionTransformer(object):
+
+    def setup_method(self):
+        names = 'a', 'd', 'g', 'o', 'c', 'phi'
+        self.hardware = DummyHardwareAdapter(names)
+        self.geometry = SixCircleGammaOnArmGeometry()
+
+        self.transform_selector = VliegTransformSelector()
+        self.transformer = VliegPositionTransformer(
+            self.geometry, self.hardware, self.transform_selector)
+        self.transform_commands = TransformCommands(self.transform_selector)
+
+        diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
+
+    def map(self, pos):  # @ReservedAssignment
+        pos = self.transformer.transform(pos)
+        angle_tuple = self.geometry.internal_position_to_physical_angles(pos)
+        angle_tuple = self.hardware.cut_angles(angle_tuple)
+        return angle_tuple
+
+    def testMapDefaultSector(self):
+
+        eq_(self.map(Pos(1, 2, 3, 4, 5, 6)),
+            (1, 2, 3, 4, 5, 6))
+
+        eq_(self.map(Pos(-180, -179, 0, 179, 180, 359)),
+            (-180, -179, 0, 179, 180, 359))
+
+        eq_(self.map(Pos(0, 0, 0, 0, 0, 0)),
+            (0, 0, 0, 0, 0, 0))
+
+        eq_(self.map(Pos(-270, 270, 0, 0, 0, -90)),
+            (90, -90, 0, 0, 0, 270))
+
+    def testMapSector1(self):
+        self.transform_commands._sectorSelector.setSector(1)
+
+        eq_(self.map(Pos(1, 2, 3, 4, 5, 6)),
+            (1, 2, 3, 4 - 180, -5, (6 - 180) + 360))
+
+        eq_(self.map(Pos(-180, -179, 0, 179, 180, 359)),
+            (-180, -179, 0, 179 - 180, -180, 359 - 180))
+
+        eq_(self.map(Pos(0, 0, 0, 0, 0, 0)),
+            (0, 0, 0, 0 - 180, 0, (0 - 180) + 360))
+
+        eq_(self.map(Pos(-270, 270, 0, 0, 0, -90)),
+            (90, -90, 0, 0 - 180, 0, 270 - 180))
+
+    def testMapAutoSector(self):
+        self.transform_commands._sectorSelector.addAutoTransorm(1)
+        self.hardware.set_lower_limit('c', 0)
+
+        eq_(self.map(Pos(1, 2, 3, 4, -5, 6)),
+            (1, 2, 3, 4 - 180, 5, (6 - 180) + 360))
+
+        eq_(self.map(Pos(-180, -179, 0, 179, -180, 359)),
+            (-180, -179, 0, 179 - 180, 180, 359 - 180))
+
+        eq_(self.map(Pos(0, 0, 0, 0, -5, 0)),
+            (0, 0, 0, 0 - 180, 5, (0 - 180) + 360))
+
+        eq_(self.map(Pos(-270, 270, 0, 0, -5, -90)),
+            (90, -90, 0, 0 - 180, 5, 270 - 180))
+
+    def testTransform(self):
+        # mapper
+        self.transform_commands.transform()  # should print its state
+        with pytest.raises(TypeError):
+            self.transform_commands.transform(1)
+        with pytest.raises(TypeError):
+            self.transform_commands.transform('a', 1)
+
+    def testTransformsOnOff(self):
+        # transforma [on/off/auto/manual]
+        ss = self.transform_commands._sectorSelector
+        self.transform_commands.transforma()  # should print mapper state
+        eq_(ss.transforms, [], "test assumes transforms are off to start")
+        self.transform_commands.transforma('on')
+        eq_(ss.transforms, ['a'])
+        self.transform_commands.transformb('on')
+        eq_(ss.transforms, ['a', 'b'])
+        self.transform_commands.transformc('off')
+        eq_(ss.transforms, ['a', 'b'])
+        self.transform_commands.transformb('off')
+        eq_(ss.transforms, ['a'])
+
+    def testTransformsAuto(self):
+        ss = self.transform_commands._sectorSelector
+        eq_(ss.autotransforms, [], "test assumes transforms are off to start")
+        self.transform_commands.transforma('auto')
+        eq_(ss.autotransforms, ['a'])
+        self.transform_commands.transformb('auto')
+        eq_(ss.autotransforms, ['a', 'b'])
+        self.transform_commands.transformc('manual')
+        eq_(ss.autotransforms, ['a', 'b'])
+        self.transform_commands.transformb('manual')
+        eq_(ss.autotransforms, ['a'])
+
+    def testTransformsBadInput(self):
+        transforma = self.transform_commands.transforma
+        with pytest.raises(TypeError):
+            transforma(1)
+        with pytest.raises(TypeError):
+            transforma('not_valid')
+        with pytest.raises(TypeError):
+            transforma('auto', 1)
+
+    def testSector(self):
+        #sector [0-7]
+        ss = self.transform_commands._sectorSelector
+        self.transform_commands.sector()  # should print mapper state
+        eq_(ss.sector, 0, "test assumes sector is 0 to start")
+        self.transform_commands.sector(1)
+        eq_(ss.sector, 1)
+        with pytest.raises(TypeError):
+            self.transform_commands.sector(1, 2)
+        with pytest.raises(TypeError):
+            self.transform_commands.sector('a')
+
+    def testAutosectors(self):
+        #autosector [0-7]
+        ss = self.transform_selector
+        self.transform_commands.autosector()  # should print mapper state
+        eq_(ss.autosectors, [], "test assumes no auto sectors to start")
+        self.transform_commands.autosector(1)
+        eq_(ss.autosectors, [1])
+        self.transform_commands.autosector(1, 2)
+        eq_(ss.autosectors, [1, 2])
+        self.transform_commands.autosector(1)
+        eq_(ss.autosectors, [1])
+        self.transform_commands.autosector(3)
+        eq_(ss.autosectors, [3])
+        with pytest.raises(TypeError):
+            self.transform_commands.autosector(1, 'a')
+        with pytest.raises(TypeError):
+            self.transform_commands.autosector('a')
+
+
+class MockLimitChecker(object):
+
+    def __init__(self):
+        self.okay = True
+
+    def isPoswithiLimits(self, pos):
+        return self.okay
+
+    def isDeltaNegative(self, pos):
+        return pos.delta <= 0
+
+
+class TestVliegTransformSelector(object):
+
+    def setup_method(self):
+        self.limitChecker = MockLimitChecker()
+        self.ss = VliegTransformSelector()
+        self.ss.limitCheckerFunction = self.limitChecker.isPoswithiLimits
+
+    def test__init__(self):
+        assert (self.ss.sector, 0)
+
+    def testCutPosition(self):
+        d = .1
+        tocut = P(-180., 180., 180. - d, 180. + d, -180. + d, -180. - d)
+        expected = P(-180., 180., 180. - d, -180. + d, -180. + d, 180. - d)
+        assert (self.ss.cutPosition(tocut) == expected)
+
+    def testTransformNWithoutCut(self):
+        pos = P(1, 2, 3, 4, 5, 6)
+        assert (self.ss.transformNWithoutCut(0, pos) == pos)
+
+    def testTransformPosition(self):
+        pos = P(0 - 360, .1 + 360, .2 - 360, .3 + 360, .4, 5)
+        res = self.ss.transformPosition(pos)
+        des = P(0, .1, .2, .3, .4, 5)
+        assert (res == des, '%s!=\n%s' % (res, des))
+
+    def testSetSector(self):
+        self.ss.setSector(4)
+        assert (self.ss.sector, 4)
+        assert (self.ss.transforms, ['b', 'c'])
+
+    def testSetTransforms(self):
+        self.ss.setTransforms(('c', 'b'))
+        assert (self.ss.sector, 4)
+        assert (self.ss.transforms, ['b', 'c'])
+
+    def testAddAutoTransormWithBadInput(self):
+        assert (self.ss.autosectors, [])
+        assert (self.ss.autotransforms, [])
+        with pytest.raises(ValueError):
+            self.ss.addAutoTransorm('not transform')
+        with pytest.raises(ValueError):
+            self.ss.addAutoTransorm(9999)
+        with pytest.raises(ValueError):
+            self.ss.addAutoTransorm([])
+
+    def testAddAutoTransormWithTransforms(self):
+        self.ss.autosectors = [1, 2, 3, 4, 5]
+        self.ss.addAutoTransorm('a')
+        print "Should now print a warning..."
+        self.ss.addAutoTransorm('a')  # twice
+        self.ss.addAutoTransorm('b')
+        assert (self.ss.autosectors, [])
+        assert (self.ss.autotransforms, ['a', 'b'])
+
+    def testAddAutoTransormWithSectors(self):
+        self.ss.autotransforms = ['a', 'c']
+        self.ss.addAutoTransorm(2)
+        print "Should now print a warning..."
+        self.ss.addAutoTransorm(2)  # twice
+        self.ss.addAutoTransorm(3)
+        assert (self.ss.autosectors, [2, 3])
+        assert (self.ss.autotransforms, [])
+
+    def testis_position_within_limits(self):
+        assert (self.ss.is_position_within_limits(None), True)
+        self.limitChecker.okay = False
+        assert (self.ss.is_position_within_limits(None), False)
+
+    def test__repr__(self):
+        self.ss.setSector(0)
+        print "************************"
+        print self.ss
+        print "************************"
+        self.ss.setTransforms('a')
+        print self.ss
+        print "************************"
+        self.ss.setTransforms(('a', 'b', 'c'))
+        print self.ss
+        print "************************"
+
+
+class TestSectorSelectorAutoCode(object):
+
+    def setup_method(self):
+        self.limitChecker = MockLimitChecker()
+        self.ss = VliegTransformSelector()
+        self.ss.limitCheckerFunction = self.limitChecker.isDeltaNegative
+        self.pos = P(0, .1, .2, .3, .4, 5)
+        self.pos_in2 = self.ss.cutPosition(
+            self.ss.transformNWithoutCut(2, self.pos))
+        self.pos_in3 = self.ss.cutPosition(
+            self.ss.transformNWithoutCut(3, self.pos))
+
+    def testAddautoTransformWithSectors(self):
+        self.ss.addAutoTransorm(2)
+        self.ss.addAutoTransorm(3)
+        assert (self.ss.autosectors, [2, 3])
+        assert (self.ss.autotransforms, [])
+        self.ss.removeAutoTransform(3)
+        assert (self.ss.autosectors, [2])
+
+    def testAddautoTransformTransforms(self):
+        self.ss.addAutoTransorm('a')
+        self.ss.addAutoTransorm('b')
+        assert (self.ss.autosectors, [])
+        assert (self.ss.autotransforms, ['a', 'b'])
+
+    def testRemoveAutoTransformWithSectors(self):
+        self.ss.addAutoTransorm(2)
+        self.ss.addAutoTransorm(3)
+        self.ss.removeAutoTransform(3)
+        assert (self.ss.autosectors, [2])
+        self.ss.removeAutoTransform(2)
+        assert (self.ss.autosectors, [])
+
+    def testRemoveAutoTransformTransforms(self):
+        self.ss.addAutoTransorm('a')
+        self.ss.addAutoTransorm('b')
+        self.ss.removeAutoTransform('b')
+        assert (self.ss.autotransforms, ['a'])
+        self.ss.removeAutoTransform('a')
+        assert (self.ss.autotransforms, [])
+
+    def testTransformPosition(self):
+        # Check that with no transforms set to autoapply, the limit
+        # checker function is ignored
+        ss = VliegTransformSelector()
+        ss.limitCheckerFunction = self.limitChecker.isPoswithiLimits
+        self.limitChecker.okay = False
+        ss.transformPosition(P(0, .1, .2, .3, .4, 5))
+
+    def testMockLimitChecker(self):
+        assert not self.limitChecker.isDeltaNegative(P(0, .1, .2, .3, .4, 5))
+        assert self.limitChecker.isDeltaNegative(P(0, -.1, .2, .3, .4, 5))
+
+    def testAutoTransformPositionWithSectors(self):
+        self.ss.addAutoTransorm(2)
+        print "Should print 'INFO: Autosector changed sector from 0 to 2':"
+        result = self.ss.autoTransformPositionBySector(self.pos)
+        assert (result == self.pos_in2)
+        assert (self.ss.sector, 2)
+
+    def testAutoTransformPositionWithSectorChoice(self):
+        self.ss.addAutoTransorm(2)
+        self.ss.addAutoTransorm(3)
+        print "Should print 'WARNING: Autosector found multiple sectors...':"
+        print "Should print 'INFO: Autosector changed sector from 0 to 2':"
+        result = self.ss.autoTransformPositionBySector(self.pos)
+        assert (result == self.pos_in2)
+        assert (self.ss.sector, 2)
+
+    def testAutoTransformPositionWithSectorsFails(self):
+        self.ss.addAutoTransorm(0)
+        self.ss.addAutoTransorm(1)
+        self.ss.addAutoTransorm(4)
+        self.ss.addAutoTransorm(5)
+        print "Should print 'INFO: Autosector changed sector from 0 to 2':"
+        with pytest.raises(Exception):
+            self.ss.autoTransformPositionBySector(self.pos)
+        #self.ss.autoTransformPositionBySector(self.pos)
+        assert (self.ss.sector, 0)  # unchanged
+
+    def testCreateListOfPossibleTransforms(self):
+        self.ss.addAutoTransorm('a')
+        assert (self.ss.createListOfPossibleTransforms(),
+                          [(), ['a', ]])
+        self.ss.addAutoTransorm('b')
+        assert (self.ss.createListOfPossibleTransforms(),
+                          [(), ['b', ], ['a', ], ['a', 'b']])
+        self.ss.transforms = ['a', 'c']
+
+    def testAutoTransformPositionWithTransforms(self):
+        self.ss.addAutoTransorm('a')
+        print "Should print 'INFO: ':"
+        result = self.ss.autoTransformPositionByTransforms(self.pos)
+        assert (result == self.pos_in2)
+        assert (self.ss.sector, 2)
+
+    def testAutoTransformPositionWithTansformsChoice(self):
+        self.ss.addAutoTransorm('a')
+        self.ss.addAutoTransorm('c')
+        print "Should print 'WARNING:':"
+        print "Should print 'INFO: ':"
+        result = self.ss.autoTransformPositionByTransforms(self.pos)
+        assert (result == self.pos_in2)
+        assert (self.ss.sector, 2)
+
+    def testTransformPositionWithAutoTransforms(self):
+        self.ss.addAutoTransorm('a')
+        assert (self.ss.transformPosition(self.pos) == self.pos_in2)
+        assert (self.ss.sector, 2)
+        print "Should not print 'INFO...'"
+        assert (self.ss.transformPosition(self.pos) == self.pos_in2)
+        assert (self.ss.sector, 2)
+
+    def testTransformPositionWithAutoTransforms2(self):
+        self.ss.addAutoTransorm(2)
+        assert (self.ss.transformPosition(self.pos) == self.pos_in2)
+        assert (self.ss.sector, 2)
+        print "Should not print 'INFO...'"
+        assert (self.ss.transformPosition(self.pos) == self.pos_in2)
+        assert (self.ss.sector, 2)
+
+    def test__repr__(self):
+        self.ss.setSector(0)
+        print "************************"
+        print self.ss
+        print "************************"
+        self.ss.setTransforms('a')
+        print self.ss
+        print "************************"
+        self.ss.setTransforms(('a', 'b', 'c'))
+        print self.ss
+        print "************************"
+
+        self.ss.addAutoTransorm(1)
+        self.ss.addAutoTransorm(2)
+        self.ss.addAutoTransorm(3)
+        print self.ss
+        print "************************"
+        self.ss.addAutoTransorm('a')
+        self.ss.addAutoTransorm('c')
+        print self.ss
+        print "************************"
+
+
+class TestTransforms(object):
+
+    def setup_method(self):
+        self.limitCheckerFunction = Mock()
+        self.ss = VliegTransformSelector()
+        self.ss.limitCheckerFunction = self.limitCheckerFunction
+
+    def applyTransforms(self, transforms, pos):
+        result = pos.clone()
+        for transform in transforms:
+            if transform == 'a':
+                result = TransformA().transform(result)
+            if transform == 'b':
+                result = TransformB().transform(result)
+            if transform == 'c':
+                result = TransformC().transform(result)
+        return self.ss.cutPosition(result)
+
+    def _testTransformN(self, n):
+        transforms = transformsFromSector[n]
+        pos = P(1, 2, 3, 4, 5, 6)
+        self.ss.setSector(n)
+        fromss = self.ss.transformPosition(pos)
+        fromhere = self.applyTransforms(transforms, pos)
+        assert (fromss == fromhere,
+                     ("sector: %i\ntransforms:%s\n%s !=\n%s" %
+                      (n, transforms, fromss, fromhere)))
+
+    def testTransform0(self):
+        self._testTransformN(0)
+
+    def testTransform1(self):
+        self._testTransformN(1)
+
+    def testTransform2(self):
+        self._testTransformN(2)
+
+    def testTransform3(self):
+        self._testTransformN(3)
+
+    def testTransform4(self):
+        self._testTransformN(5)
+
+    def testTransform5(self):
+        self._testTransformN(5)
+
+    def testTransform6(self):
+        self._testTransformN(6)
+
+    def testTransform7(self):
+        self._testTransformN(7)
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/willmot/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/willmot/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/willmot/test_calcwill.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/willmot/test_calcwill.py
new file mode 100644
index 0000000..a89e66b
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/willmot/test_calcwill.py	
@@ -0,0 +1,323 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+# TODO: class largely copied from test_calc
+
+from math import pi
+from mock import Mock
+from nose.tools import raises
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.hkl.willmott.calc import \
+    WillmottHorizontalUbCalcStrategy, WillmottHorizontalCalculator, \
+    WillmottHorizontalPosition as Pos, WillmottHorizontalGeometry
+from test.tools import assert_array_almost_equal, \
+    assert_second_dict_almost_in_first, matrixeq_
+from diffcalc.ub.calc import UBCalculation
+from diffcalc.ub.crystal import CrystalUnderTest
+from diffcalc.ub.persistence import UbCalculationNonPersister
+from diffcalc.util import DiffcalcException
+from test.diffcalc.test_hardware import SimpleHardwareAdapter
+from test.diffcalc.hkl.vlieg.test_calc import createMockUbcalc, \
+    createMockDiffractometerGeometry
+import diffcalc.hkl.willmott.calc  # @UnusedImport
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+
+class _BaseTest():
+
+    def setup_method(self):
+        self.mock_ubcalc = createMockUbcalc(None)
+        self.mock_geometry = createMockDiffractometerGeometry()
+        self.mock_hardware = SimpleHardwareAdapter(
+                             ['delta', 'gamma', 'omegah', 'phi'])
+        self.constraints = Mock()
+        self.calc = WillmottHorizontalCalculator(self.mock_ubcalc,
+                    self.mock_geometry, self.mock_hardware, self.constraints)
+
+        self.places = 12
+
+    def _check_hkl_to_angles(self, testname, zrot, yrot, hkl, pos_expected,
+                             wavelength, virtual_expected={}):
+        print ('_check_hkl_to_angles(%s, %.1f, %.1f, %s, %s, %.2f, %s)'
+               % (testname, zrot, yrot, hkl, pos_expected, wavelength,
+                  virtual_expected))
+        self.zrot, self.yrot = zrot, yrot
+        self._configure_ub()
+        pos, virtual = self.calc.hklToAngles(hkl[0], hkl[1], hkl[2],
+                                             wavelength)
+        assert_array_almost_equal(pos.totuple(), pos_expected.totuple(),
+                                  self.places)
+        assert_second_dict_almost_in_first(virtual, virtual_expected)
+
+    def _check_angles_to_hkl(self, testname, zrot, yrot, hkl_expected, pos,
+                             wavelength, virtual_expected={}):
+        print ('_check_angles_to_hkl(%s, %.1f, %.1f, %s, %s, %.2f, %s)' %
+               (testname, zrot, yrot, hkl_expected, pos, wavelength,
+                virtual_expected))
+        self.zrot, self.yrot = zrot, yrot
+        self._configure_ub()
+        hkl, virtual = self.calc.anglesToHkl(pos, wavelength)
+        assert_array_almost_equal(hkl, hkl_expected, self.places)
+        assert_second_dict_almost_in_first(virtual, virtual_expected)
+
+    @raises(DiffcalcException)
+    def _check_hkl_to_angles_fails(self, *args):
+        self._check_hkl_to_angles(*args)
+
+
+# Primary and secondary reflections found with the help of DDIF on Diamond's
+# i07 on Jan 27 2010
+
+Si_5_5_12_WAVELENGTH = 0.6358
+Si_5_5_12_HKL0 = 2, 19, 32
+Si_5_5_12_REF0 = Pos(delta=21.975, gamma=4.419, omegah=2, phi=326.2)
+Si_5_5_12_HKL1 = 0, 7, 22
+Si_5_5_12_REF1 = Pos(delta=11.292, gamma=2.844, omegah=2, phi=124.1)
+
+# This is U matrix displayed by DDIF
+U_FROM_DDIF = matrix([[0.233140, 0.510833, 0.827463],
+                      [-0.65596, -0.545557, 0.521617],
+                      [0.717888, -0.664392, 0.207894]])
+
+# This is the version that Diffcalc comes up with ( see following test)
+Si_5_5_12_U_DIFFCALC = matrix([[-0.7178876, 0.6643924, -0.2078944],
+                     [-0.6559596, -0.5455572, 0.5216170],
+                     [0.2331402, 0.5108327, 0.8274634]])
+
+
+class TestUBCalculationWithWillmotStrategy_Si_5_5_12():
+
+    def setup_method(self):
+        hardware = Mock()
+        hardware.get_axes_names.return_value = ('d', 'g', 'oh', 'p')
+        self.ubcalc = UBCalculation(hardware, WillmottHorizontalGeometry(),
+                                    UbCalculationNonPersister(),
+                                    WillmottHorizontalUbCalcStrategy())
+
+    def testAgainstResultsFromJan_27_2010(self):
+        self.ubcalc.start_new('test')
+        self.ubcalc.set_lattice('Si_5_5_12', 7.68, 53.48, 75.63, 90, 90, 90)
+        self.ubcalc.add_reflection(
+            Si_5_5_12_HKL0[0], Si_5_5_12_HKL0[1], Si_5_5_12_HKL0[2],
+            Si_5_5_12_REF0, 12.39842 / Si_5_5_12_WAVELENGTH, 'ref0', None)
+        self.ubcalc.add_reflection(
+            Si_5_5_12_HKL1[0], Si_5_5_12_HKL1[1], Si_5_5_12_HKL1[2],
+            Si_5_5_12_REF1, 12.39842 / Si_5_5_12_WAVELENGTH, 'ref1', None)
+        self.ubcalc.calculate_UB()
+        print "U: ", self.ubcalc.U
+        print "UB: ", self.ubcalc.UB
+        matrixeq_(self.ubcalc.U, Si_5_5_12_U_DIFFCALC)
+
+
+class TestSurfaceNormalVertical_Si_5_5_12_PosGamma(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self.constraints.reference = {'betain': 2}
+        self.wavelength = 0.6358
+        B = CrystalUnderTest('xtal', 7.68, 53.48,
+                             75.63, 90, 90, 90).B
+        self.UB = Si_5_5_12_U_DIFFCALC * B
+        diffcalc.hkl.willmott.calc.CHOOSE_POSITIVE_GAMMA = True
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        self._check_angles_to_hkl('', 999, 999, hkl, pos, self.wavelength,
+                                  virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails('', 999, 999, hkl, pos,
+                                            self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles('', 999, 999, hkl, pos, self.wavelength,
+                                      virtual_expected)
+
+    def testHkl_2_19_32_found_orientation_setting(self):
+        '''Check that the or0 reflection maps back to the assumed hkl'''
+        self.places = 2
+        self._check_angles_to_hkl('', 999, 999, Si_5_5_12_HKL0,
+                        Si_5_5_12_REF0,
+                        self.wavelength, {'betain': 2})
+
+    def testHkl_0_7_22_found_orientation_setting(self):
+        '''Check that the or1 reflection maps back to the assumed hkl'''
+        self.places = 0
+        self._check_angles_to_hkl('', 999, 999, Si_5_5_12_HKL1,
+                        Si_5_5_12_REF1,
+                        self.wavelength, {'betain': 2})
+
+    def testHkl_2_19_32_calculated_from_DDIF(self):
+        self.places = 3
+        self._check((2, 19, 32),
+                    Pos(delta=21.974, gamma=4.419, omegah=2, phi=-33.803),
+                    {'betain': 2})
+
+    def testHkl_0_7_22_calculated_from_DDIF(self):
+        self.places = 3
+        self._check((0, 7, 22),
+                    Pos(delta=11.242, gamma=3.038, omegah=2, phi=123.064),
+                    {'betain': 2})
+
+    def testHkl_2_m5_12_calculated_from_DDIF(self):
+        self.places = 3
+        self._check((2, -5, 12),
+                    Pos(delta=5.224, gamma=10.415, omegah=2, phi=-1.972),
+                    {'betain': 2})
+
+# conlcusion:
+# given or1 from testHkl_2_19_32_found_orientation_setting and,
+# or1 from testHkl_0_7_22_found_orientation_setting
+# we can calculate a U matrix which agrees with that from diff except for
+# signs and row order
+# We can also calculate values for 2_19_32 and 0_7_22 that match those
+# calculated by DDIF to the number of recorded decimal places (3)
+
+
+class SkipTestSurfaceNormalVertical_Si_5_5_12_NegGamma(
+    TestSurfaceNormalVertical_Si_5_5_12_PosGamma):
+    """When choosing -ve gamma delta ends up being -ve too"""
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self.constraints.reference = {'betain': 2 * TORAD}
+        self.wavelength = 0.6358
+        B = CrystalUnderTest('xtal', 7.68, 53.48,
+                             75.63, 90, 90, 90).B
+        self.UB = Si_5_5_12_U_DIFFCALC * B
+        diffcalc.hkl.willmott.calc.CHOOSE_POSITIVE_GAMMA = False
+
+
+##################################################################
+
+# Primary and secondary reflections found with the help of DDIF on Diamond's
+# i07 on Jan 28/29 2010
+
+
+Pt531_HKL0 = -1.000, 1.000, 6.0000
+Pt531_REF0 = Pos(delta=9.465, gamma=16.301, omegah=2,
+                                  phi=307.94 - 360)
+Pt531_REF0_DIFFCALC = Pos(
+    9.397102509657, 16.181230279320, 2.000000000000, -52.139290474913)
+
+Pt531_HKL1 = -2.000, -1.000, 7.0000
+Pt531_REF1 = Pos(delta=11.094, gamma=11.945, omegah=2, phi=238.991 - 360)
+Pt531_REF1_DIFFCALC = Pos(
+    11.012695836306, 11.863612760237, 2.000000000000, -121.215597507237)
+
+Pt531_HKL2 = 1, 1, 9
+Pt531_REF2 = Pos(delta=14.272, gamma=7.806, omegah=2,
+                                  phi=22.9)
+Pt531_REF2_DIFFCALC = Pos(
+    14.188161709766, 7.758593908726, 2.000000000000, 23.020313153847)
+Pt531_WAVELENGTH = 0.6358
+
+# This is U matrix displayed by DDIF
+U_FROM_DDIF = matrix([[-0.00312594, -0.00063417, 0.99999491],
+                      [0.99999229, -0.00237817, 0.00312443],
+                      [0.00237618, 0.99999697, 0.00064159]])
+
+# This is the version that Diffcalc comes up with ( see following test)
+Pt531_U_DIFFCALC = matrix([[-0.0023763, -0.9999970, -0.0006416],
+                           [0.9999923, -0.0023783, 0.0031244],
+                           [-0.0031259, -0.0006342, 0.9999949]])
+
+
+class TestUBCalculationWithWillmotStrategy_Pt531():
+
+    def setup_method(self):
+        hardware = Mock()
+        hardware.get_axes_names.return_value = ('d', 'g', 'oh', 'p')
+        self.ubcalc = UBCalculation(hardware, WillmottHorizontalGeometry(),
+                                    UbCalculationNonPersister(),
+                                    WillmottHorizontalUbCalcStrategy())
+
+    def testAgainstResultsFromJan_27_2010(self):
+        self.ubcalc.start_new('test')
+        self.ubcalc.set_lattice('Pt531', 6.204, 4.806, 23.215, 90, 90, 49.8)
+        self.ubcalc.add_reflection(
+            Pt531_HKL0[0], Pt531_HKL0[1], Pt531_HKL0[2], Pt531_REF0,
+            12.39842 / Pt531_WAVELENGTH, 'ref0', None)
+        self.ubcalc.add_reflection(
+            Pt531_HKL1[0], Pt531_HKL1[1], Pt531_HKL1[2], Pt531_REF1,
+            12.39842 / Pt531_WAVELENGTH, 'ref1', None)
+        self.ubcalc.calculate_UB()
+        print "U: ", self.ubcalc.U
+        print "UB: ", self.ubcalc.UB
+        matrixeq_(self.ubcalc.U, Pt531_U_DIFFCALC)
+
+
+class TestSurfaceNormalVertical_Pt531_PosGamma(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self.constraints.reference = {'betain': 2}
+        self.wavelength = Pt531_WAVELENGTH
+
+        cut = CrystalUnderTest('Pt531', 6.204, 4.806, 23.215, 90, 90, 49.8)
+        B = cut.B
+        self.UB = Pt531_U_DIFFCALC * B
+        diffcalc.hkl.willmott.calc.CHOOSE_POSITIVE_GAMMA = True
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+#        self._check_angles_to_hkl('', 999, 999, hkl, pos, self.wavelength,
+#                                  virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails('', 999, 999, hkl, pos,
+                                            self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles('', 999, 999, hkl, pos, self.wavelength,
+                                      virtual_expected)
+
+    def testHkl_0_found_orientation_setting(self):
+        '''Check that the or0 reflection maps back to the assumed hkl'''
+        self.places = 1
+        self._check_angles_to_hkl('', 999, 999, Pt531_HKL0,
+                        Pt531_REF0,
+                        self.wavelength, {'betain': 2})
+
+    def testHkl_1_found_orientation_setting(self):
+        '''Check that the or1 reflection maps back to the assumed hkl'''
+        self.places = 0
+        self._check_angles_to_hkl('', 999, 999, Pt531_HKL1,
+                        Pt531_REF1,
+                        self.wavelength, {'betain': 2})
+
+    def testHkl_0_predicted_versus_found_during_oriantation_phase(self):
+        self._check(Pt531_HKL0,
+                    Pt531_REF0_DIFFCALC,  # inspected as close to Pt531_REF0
+                    {'betain': 2})
+
+    def testHkl_1_predicted_versus_found_during_oriantation_phase(self):
+        self._check(Pt531_HKL1,
+                    Pt531_REF1_DIFFCALC,  # inspected as close to Pt531_REF1,
+                    {'betain': 2})
+
+    def testHkl_2_predicted_versus_found_during_oriantation_phase(self):
+        self._check(Pt531_HKL2,
+                    Pt531_REF2_DIFFCALC,  # inspected as close to Pt531_REF2
+                    {'betain': 2})
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/you/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc.py
new file mode 100644
index 0000000..93daec8
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc.py	
@@ -0,0 +1,1265 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi, cos, sin
+from nose.tools import raises
+from mock import Mock
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.hkl.you.calc import YouHklCalculator
+from diffcalc.hkl.you.constraints import YouConstraintManager
+from test.tools import assert_array_almost_equal, \
+    assert_second_dict_almost_in_first, arrayeq_
+from diffcalc.ub.crystal import CrystalUnderTest
+from diffcalc.util import y_rotation, z_rotation, DiffcalcException
+from test.diffcalc.test_hardware import SimpleHardwareAdapter
+from diffcalc.hkl.you.geometry import YouPosition as Pos, SixCircle, YouGeometry
+from diffcalc.hkl.you.calc import youAnglesToHkl
+
+TORAD = pi / 180
+TODEG = 180 / pi
+I = matrix('1 0 0; 0 1 0; 0 0 1')
+
+from diffcalc.hkl.you.constraints import NUNAME
+
+class Pair:
+
+    def __init__(self, name, hkl, position, fails=False):
+        self.name = name
+        self.hkl = hkl
+        self.position = position
+        self.fails = fails
+
+
+def createMockUbcalc(UB):
+    ubcalc = Mock()
+    ubcalc.tau = 0
+    ubcalc.sigma = 0
+    ubcalc.UB = UB
+    ubcalc.n_phi = matrix([[0], [0], [1]])
+    return ubcalc
+
+
+class _BaseTest(object):
+
+    def setup_method(self):
+        self.mock_ubcalc = createMockUbcalc(None)
+        self.sixc_geometry = SixCircle()
+        names = ['mu', 'delta', NUNAME, 'eta', 'chi', 'phi']
+        self.mock_hardware = SimpleHardwareAdapter(names)
+        self.constraints = YouConstraintManager(self.mock_hardware)
+        self.calc = YouHklCalculator(self.mock_ubcalc, self.sixc_geometry,
+                                     self.mock_hardware, self.constraints)
+
+        self.mock_hardware.set_lower_limit('delta', 0)
+        self.mock_hardware.set_upper_limit('delta', 179.999)
+        self.mock_hardware.set_lower_limit(NUNAME, 0)
+        self.mock_hardware.set_upper_limit(NUNAME, 179.999)
+        self.mock_hardware.set_lower_limit('mu', 0)
+        self.mock_hardware.set_lower_limit('eta', 0)
+        self.mock_hardware.set_upper_limit('chi', 179.999)
+        self.mock_hardware.set_lower_limit('chi', -10)
+        self.mock_hardware.set_cut('phi', -179.999)
+
+        self.places = 5
+
+    def _configure_ub(self):
+        ZROT = z_rotation(self.zrot * TORAD)  # -PHI
+        YROT = y_rotation(self.yrot * TORAD)  # +CHI
+        U = ZROT * YROT
+        UB = U * self.B
+        self.mock_ubcalc.UB = UB
+
+    def _check_hkl_to_angles(self, testname, zrot, yrot, hkl, pos_expected,
+                             wavelength, virtual_expected={}):
+        print ('_check_hkl_to_angles(%s, %.1f, %.1f, %s, %s, %.2f, %s)' %
+               (testname, zrot, yrot, hkl, pos_expected, wavelength,
+                virtual_expected))
+        self.zrot, self.yrot = zrot, yrot
+        self._configure_ub()
+
+        pos, virtual = self.calc.hklToAngles(hkl[0], hkl[1], hkl[2],
+                                             wavelength)
+        assert_array_almost_equal(pos.totuple(), pos_expected.totuple(),
+                                  self.places)
+        assert_second_dict_almost_in_first(virtual, virtual_expected)
+
+    def _check_angles_to_hkl(self, testname, zrot, yrot, hkl_expected, pos,
+                             wavelength, virtual_expected={}):
+        print ('_check_angles_to_hkl(%s, %.1f, %.1f, %s, %s, %.2f, %s)' %
+               (testname, zrot, yrot, hkl_expected, pos, wavelength,
+                virtual_expected))
+        self.zrot, self.yrot = zrot, yrot
+        self._configure_ub()
+        hkl, virtual = self.calc.anglesToHkl(pos, wavelength)
+        assert_array_almost_equal(hkl, hkl_expected, self.places, note="***Test (not diffcalc!) incorrect*** : the desired settings do not map to the target hkl")
+        assert_second_dict_almost_in_first(virtual, virtual_expected)
+
+    @raises(DiffcalcException)
+    def _check_hkl_to_angles_fails(self, *args):
+        self._check_hkl_to_angles(*args)
+
+    def case_generator(self):
+        for case in self.case_dict.values():
+            yield (self._check_angles_to_hkl, case.name, self.zrot, self.yrot,
+                   case.hkl, case.position, self.wavelength, {})
+            test_method = (self._check_hkl_to_angles_fails if case.fails else
+                           self._check_hkl_to_angles)
+            yield (test_method, case.name, self.zrot, self.yrot, case.hkl,
+                                case.position, self.wavelength, {})
+
+
+class _TestCubic(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self.B = I * 2 * pi
+
+
+class _TestCubicVertical(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+            Pair('100', (1, 0, 0),
+                 Pos(mu=0, delta=60, nu=0, eta=30, chi=0 - self.yrot,
+                     phi=0 + self.zrot, unit='DEG')),
+            Pair('100-->001', (cos(4 * TORAD), 0, sin(4 * TORAD)),
+                 Pos(mu=0, delta=60, nu=0, eta=30, chi=4 - self.yrot,
+                     phi=0 + self.zrot, unit='DEG'),),
+            Pair('010', (0, 1, 0),
+                 Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=90 + self.zrot, unit='DEG')),
+            Pair('001', (0, 0, 1),
+                 Pos(mu=0, delta=60, nu=0, eta=30, chi=90 - self.yrot,
+                     phi=0 + self.zrot, unit='DEG')),
+            Pair('0.1 0 1.5', (0.1, 0, 1.5),  # cover case where delta > 90 !
+                  Pos(mu=0, delta=97.46959231642, nu=0,
+                      eta=97.46959231642/2, chi=86.18592516571 - self.yrot,
+                      phi=0 + self.zrot, unit='DEG')),
+            Pair('001-->100', (cos(86 * TORAD), 0, sin(86 * TORAD)),
+                 Pos(mu=0, delta=60, nu=0, eta=30, chi=86 - self.yrot,
+                     phi=0 + self.zrot, unit='DEG')),
+        )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_various_zrot_and_yrot0(self):
+        for zrot in [0, 2, -2, 45, -45, 90, -90]:  # -180, 180 work if recut
+            self.makes_cases(zrot, 0)
+            self.case_dict['001'].fails = True  # q||n
+            for case_tuple in self.case_generator():
+                yield case_tuple
+
+    def test_hkl_to_angles_zrot1_yrot2(self):
+        self.makes_cases(1, 2)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+    def test_hkl_to_angles_zrot1_yrotm2(self):
+        self.makes_cases(1, -2)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+    def test_hkl_to_angles_zrotm1_yrot2(self):
+        self.makes_cases(-1, 2)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+    def test_hkl_to_angles_zrotm1_yrotm2(self):
+        self.makes_cases(-1, -2)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+    def testHklDeltaGreaterThan90(self):
+        wavelength = 1            
+        hkl = (0.1, 0, 1.5)
+        pos = Pos(mu=0, delta=97.46959231642, nu=0,
+                      eta=97.46959231642/2, chi=86.18592516571,
+                      phi=0, unit='DEG')
+        self._check_hkl_to_angles('', 0, 0, hkl, pos, wavelength)
+
+
+class TestCubicVertical_aeqb(_TestCubicVertical):
+
+    def setup_method(self):
+        _TestCubicVertical.setup_method(self)
+        self.constraints._constrained = {'a_eq_b': None, 'mu': 0, NUNAME: 0}
+
+
+class TestCubicVertical_psi_90(_TestCubicVertical):
+    '''mode psi=90 should be the same as mode a_eq_b'''
+
+    def setup_method(self):
+        _TestCubicVertical.setup_method(self)
+        self.constraints._constrained = {'psi': 90 * TORAD, 'mu': 0, NUNAME: 0}
+
+    def test_pairs_various_zrot_and_yrot0(self):
+        for zrot in [0, 2, -2, 45, -45, 90, -90]:  # -180, 180 work if recut
+            self.makes_cases(zrot, 0)
+            self.case_dict['001'].fails = True  # q||n psi is undefined
+            for case_tuple in self.case_generator():
+                yield case_tuple
+
+    def test_hkl_to_angles_zrot1_yrotm2(self):
+        self.constraints._constrained = {'psi': -90 * TORAD, 'mu': 0, NUNAME: 0}
+        super(TestCubicVertical_psi_90, self).test_hkl_to_angles_zrot1_yrotm2()
+
+    def test_hkl_to_angles_zrotm1_yrotm2(self):
+        self.constraints._constrained = {'psi': -90 * TORAD, 'mu': 0, NUNAME: 0}
+        super(TestCubicVertical_psi_90, self).test_hkl_to_angles_zrotm1_yrotm2()
+
+class TestCubicVertical_qaz_90(_TestCubicVertical):
+    '''mode psi=90 should be the same as mode a_eq_b'''
+
+    def setup_method(self):
+        _TestCubicVertical.setup_method(self)
+        self.constraints._constrained = {'a_eq_b': None, 'mu': 0,
+                                         'qaz': 90 * TORAD}
+
+
+class TestCubicVertical_ChiPhiMode(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.constraints._constrained = {NUNAME: 0, 'chi': 90. * TORAD, 'phi': 0.}
+        self.mock_hardware.set_lower_limit('mu', -180.)
+        self.mock_hardware.set_lower_limit('eta', -180.)
+        self.places = 5
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+            Pair('110', (1, 1, 0),
+                 Pos(mu=-90, delta=90, nu=0, eta=90, chi=90,
+                     phi=0, unit='DEG')),
+            Pair('100-->001', (sin(4 * TORAD), 0, cos(4 * TORAD)),
+                 Pos(mu=-8.01966360660, delta=60, nu=0, eta=29.75677306273, chi=90,
+                     phi=0, unit='DEG'),),
+            Pair('010', (0, 1, 0),
+                 Pos(mu=0, delta=60, nu=0, eta=120, chi=90, phi=0, unit='DEG')),
+            Pair('001', (0, 0, 1),
+                 Pos(mu=0, delta=60, nu=0, eta=30 - self.yrot, chi=90,
+                     phi=0, unit='DEG')),
+            Pair('0.1 0 1.5', (0.1, 0, 1.5),  # cover case where delta > 90 !
+                  Pos(mu=-5.077064540005, delta=97.46959231642, nu=0,
+                      eta=48.62310452627, chi=90 - self.yrot,
+                      phi=0 + self.zrot, unit='DEG')),
+            Pair('010-->001', (0, cos(86 * TORAD), sin(86 * TORAD)),
+                 Pos(mu=0, delta=60, nu=0, eta=34, chi=90,
+                     phi=0, unit='DEG')),
+        )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_zrot0_yrot0(self):
+        self.makes_cases(0, 0)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+class TestCubic_FixedPhiMode(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.constraints._constrained = {'mu': 0, NUNAME: 0, 'phi': 0}
+        self.mock_hardware.set_upper_limit('chi', 180.)
+        self.mock_hardware.set_lower_limit('chi', -180.)
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+            Pair('100', (1, 0, 0),
+                 Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=0 - self.yrot,
+                     phi=0, unit='DEG')),
+            Pair('100-->001', (cos(4 * TORAD), 0, sin(4 * TORAD)),
+                 Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=4 - self.yrot,
+                     phi=0, unit='DEG'),),
+            #Pair('010', (0, 1, 0),
+            #     Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=0, phi=90, unit='DEG')),
+            Pair('001', (0, 0, 1),
+                 Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=90 - self.yrot,
+                     phi=0, unit='DEG')),
+            Pair('0.1 0 1.5', (0.1, 0, 1.5),  # cover case where delta > 90 !
+                  Pos(mu=0, delta=97.46959231642, nu=0,
+                      eta=97.46959231642/2 + self.zrot, chi=86.18592516571 - self.yrot,
+                      phi=0, unit='DEG')),
+            Pair('001-->100', (cos(86 * TORAD), 0, sin(86 * TORAD)),
+                 Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=86 - self.yrot,
+                     phi=0, unit='DEG')),
+        )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_various_zrot0_and_yrot(self):
+        for yrot in [0, 2, -2, 45, -45, 90, -90]:  # -180, 180 work if recut
+            self.makes_cases(0, yrot)
+            for case_tuple in self.case_generator():
+                yield case_tuple
+
+class TestCubic_FixedPhi30Mode(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.constraints._constrained = {'mu': 0, NUNAME: 0, 'phi': 30 * TORAD}
+        self.mock_hardware.set_upper_limit('chi', 180.)
+        self.mock_hardware.set_lower_limit('chi', -180.)
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+            Pair('100', (1, 0, 0),
+                 Pos(mu=0, delta=60, nu=0, eta=0 + self.zrot, chi=0 - self.yrot,
+                     phi=30, unit='DEG')),
+            #Pair('100-->001', (cos(4 * TORAD), 0, sin(4 * TORAD)),
+            #     Pos(mu=0, delta=60, nu=0, eta=0 + self.zrot, chi=4 - self.yrot,
+            #         phi=30, unit='DEG'),),
+            #Pair('010', (0, 1, 0),
+            #     Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=0, phi=90, unit='DEG')),
+            Pair('001', (0, 0, 1),
+                 Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=90 - self.yrot,
+                     phi=30, unit='DEG')),
+            Pair('0.1 0 1.5', (0.1, 0, 1.5),  # cover case where delta > 90 !
+                  Pos(mu=0, delta=97.46959231642, nu=0,
+                      eta=46.828815370173 + self.zrot, chi=86.69569481984 - self.yrot,
+                      phi=30, unit='DEG')),
+            #Pair('001-->100', (cos(86 * TORAD), 0, sin(86 * TORAD)),
+            #     Pos(mu=0, delta=60, nu=0, eta=0 + self.zrot, chi=86 - self.yrot,
+            #         phi=30, unit='DEG')),
+        )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_zrot0_and_yrot0(self):
+        self.makes_cases(0, 0)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+class TestCubic_FixedPhiMode010(TestCubic_FixedPhiMode):
+
+    def setup_method(self):
+        TestCubic_FixedPhiMode.setup_method(self)
+        self.constraints._constrained = {'mu': 0, NUNAME: 0, 'phi': 90 * TORAD}
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+            Pair('010', (0, 1, 0),
+                 Pos(mu=0, delta=60, nu=0, eta=30 + self.zrot, chi=0, phi=90, unit='DEG')),
+        )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_various_zrot0_and_yrot(self):
+        for yrot in [0, 2, -2, 45, -45, 90, -90]:  # -180, 180 work if recut
+            self.makes_cases(0, yrot)
+            
+            for case_tuple in self.case_generator():
+                yield case_tuple
+
+class TestCubicVertical_MuEtaMode(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.constraints._constrained = {NUNAME: 0, 'mu': 90. * TORAD, 'eta': 0.}
+        self.mock_hardware.set_lower_limit('chi', -180.)
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+            Pair('011', (0, 1, 1),
+                 Pos(mu=90, delta=90, nu=0, eta=0, chi=0,
+                     phi=90, unit='DEG')),
+            Pair('100-->001', (sin(4 * TORAD), 0, cos(4 * TORAD)),
+                 Pos(mu=90, delta=60, nu=0, eta=0, chi=56,
+                     phi=0, unit='DEG'),),
+            Pair('010', (0, 1, 0),
+                 Pos(mu=90, delta=60, nu=0, eta=0, chi=-30, phi=90, unit='DEG')),
+            Pair('001', (0, 0, 1),
+                 Pos(mu=90, delta=60, nu=0, eta=0, chi=60,
+                     phi=0, unit='DEG')),
+            Pair('0.1 0 1.5', (0.1, 0, 1.5),  # cover case where delta > 90 !
+                  Pos(mu=90, delta=97.46959231642, nu=0,
+                      eta=0, chi=37.45112900750 - self.yrot,
+                      phi=0 + self.zrot, unit='DEG')),
+            Pair('010-->001', (0, cos(86 * TORAD), sin(86 * TORAD)),
+                 Pos(mu=90, delta=60, nu=0, eta=0, chi=56,
+                     phi=90, unit='DEG')),
+        )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_zrot0_yrot0(self):
+        self.makes_cases(0, 0)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+
+class SkipTestYouHklCalculatorWithCubicMode_aeqb_delta_60(_TestCubicVertical):
+    '''
+    Works to 4-5 decimal places but chooses different solutions when phi||eta .
+    Skip all tests.
+    '''
+
+    def setup_method(self):
+        _TestCubicVertical.setup_method(self)
+        self.constraints._constrained = {'a_eq_b': None, 'mu': 0,
+                                         'delta': 60 * TORAD}
+        self.places = 5
+
+
+class _TestCubicHorizontal(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+
+    def makes_cases(self, zrot, yrot):
+        self.zrot = zrot
+        self.yrot = yrot
+        self.wavelength = 1
+        self.cases = (
+             Pair('100', (1, 0, 0),
+                  Pos(mu=30, delta=0, nu=60, eta=0, chi=90 + self.yrot,
+                      phi=-180 + self.zrot, unit='DEG')),
+             Pair('100-->001', (cos(4 * TORAD), 0, sin(4 * TORAD)),
+                  Pos(mu=30, delta=0, nu=60, eta=0, chi=90 - 4 + self.yrot,
+                      phi=-180 + self.zrot, unit='DEG')),
+             Pair('010', (0, 1, 0),
+                  Pos(mu=30, delta=0, nu=60, eta=0, chi=90,
+                      phi=-90 + self.zrot, unit='DEG')),  # no yrot as chi||q
+             Pair('001', (0, 0, 1),
+                  Pos(mu=30, delta=0, nu=60, eta=0, chi=0 - self.yrot,
+                      phi=0 + self.zrot, unit='DEG')),
+             Pair('001-->100', (cos(86 * TORAD), 0, sin(86 * TORAD)),
+                  Pos(mu=30, delta=0, nu=60, eta=0, chi=0 - 4 - self.yrot,
+                      phi=0 + self.zrot, unit='DEG')),
+            )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def test_pairs_zrot0_yrot0(self):
+        self.makes_cases(0, 0)
+        self.case_dict['001'].fails = True  # q||n
+        self.case_dict['100'].position.phi = 180  # not -180
+        self.case_dict['100-->001'].position.phi = 180  # not -180
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+#    def test_pairs_various_zrot_and_yrot0(self):
+#        for zrot in [0, 2, -2, 45, -45, 90, -90]:
+# -180, 180 work but with cut problem
+#            self.makes_cases(zrot, 0)
+#            self.case_dict['001'].fails = True # q||n
+#            for case_tuple in self.case_generator():
+#                yield case_tuple
+
+    def test_hkl_to_angles_zrot1_yrot2(self):
+        self.makes_cases(1, 2)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+    def test_hkl_to_angles_zrot1_yrotm2(self):
+        self.makes_cases(1, -2)
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+
+class TestCubicHorizontal_qaz0_aeqb(_TestCubicHorizontal):
+
+    def setup_method(self):
+        _TestCubicHorizontal.setup_method(self)
+        self.constraints._constrained = {'a_eq_b': None, 'qaz': 0, 'eta': 0}
+
+
+class TestCubicHorizontal_delta0_aeqb(_TestCubicHorizontal):
+
+    def setup_method(self):
+        _TestCubicHorizontal.setup_method(self)
+        self.constraints._constrained = {'a_eq_b': None, 'delta': 0, 'eta': 0}
+
+
+class TestAgainstSpecSixcB16_270608(_BaseTest):
+    '''NOTE: copied from test.diffcalc.scenarios.session3'''
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+
+        U = matrix(((0.997161, -0.062217, 0.042420),
+                    (0.062542, 0.998022, -0.006371),
+                    (-0.041940, 0.009006, 0.999080)))
+
+        B = matrix(((1.636204, 0, 0),
+                    (0, 1.636204, 0),
+                    (0, 0, 1.156971)))
+
+        self.UB = U * B
+        self.constraints._constrained = {'a_eq_b': None, 'mu': 0, NUNAME: 0}
+        self.places = 2  # TODO: the Vlieg code got this to 3 decimal places
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def makes_cases(self, zrot, yrot):
+        del zrot, yrot  # not used
+        self.wavelength = 1.24
+        self.cases = (
+            Pair('7_9_13', (0.7, 0.9, 1.3),
+                 Pos(mu=0, delta=27.352179, nu=0, eta=13.676090,
+                     chi=37.774500, phi=53.965500, unit='DEG')),
+            Pair('100', (1, 0, 0),
+                 Pos(mu=0, delta=18.580230, nu=0, eta=9.290115,
+                     chi=-2.403500, phi=3.589000, unit='DEG')),
+            Pair('010', (0, 1, 0),
+                 Pos(mu=0, delta=18.580230, nu=0, eta=9.290115,
+                     chi=0.516000, phi=93.567000, unit='DEG')),
+            Pair('110', (1, 1, 0),
+                 Pos(mu=0, delta=26.394192, nu=0, eta=13.197096,
+                     chi=-1.334500, phi=48.602000, unit='DEG')),
+            )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def case_generator(self):
+        zrot, yrot = 999, 999
+        for case in self.cases:
+            yield (self._check_angles_to_hkl, case.name, zrot, yrot, case.hkl,
+                   case.position, self.wavelength, {})
+            test_method = (self._check_hkl_to_angles_fails if case.fails else
+                           self._check_hkl_to_angles)
+            yield (test_method, case.name, zrot, yrot, case.hkl, case.position,
+                   self.wavelength, {})
+
+    def test_hkl_to_angles_given_UB(self):
+        self.makes_cases(None, None)  # xrot, yrot unused
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+
+class SkipTestThreeTwoCircleForDiamondI06andI10(_BaseTest):
+    """
+    This is a three circle diffractometer with only delta and omega axes
+    and a chi axis with limited range around 90. It is operated with phi
+    fixed and can only reach reflections with l (or z) component.
+
+    The data here is taken from an experiment performed on Diamonds I06
+    beamline.
+    """
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self.constraints._constrained = {'phi': -pi / 2, NUNAME: 0, 'mu': 0}
+        self.wavelength = 12.39842 / 1.650
+
+    def _configure_ub(self):
+        U = matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        B = CrystalUnderTest('xtal', 5.34, 5.34, 13.2, 90, 90, 90).B
+        self.mock_ubcalc.UB = U * B
+
+    def testHkl001(self):
+        hkl = (0, 0, 1)
+        pos = Pos(mu=0, delta=33.07329403295449, nu=0, eta=16.536647016477247,
+                  chi=90, phi=-90, unit='DEG')
+        self._check_angles_to_hkl(
+            '001', 999, 999, hkl, pos, self.wavelength, {})
+        self._check_hkl_to_angles(
+            '001', 999, 999, hkl, pos, self.wavelength, {})
+
+    def testHkl100(self):
+        hkl = (1, 0, 0)
+        pos = Pos(mu=0, delta=89.42926563609406, nu=0, eta=134.71463281804702,
+                  chi=90, phi=-90, unit='DEG')
+        self._check_angles_to_hkl(
+            '100', 999, 999, hkl, pos, self.wavelength, {})
+        self._check_hkl_to_angles(
+            '100', 999, 999, hkl, pos, self.wavelength, {})
+
+    def testHkl101(self):
+        hkl = (1, 0, 1)
+        pos = Pos(mu=0, delta=98.74666191021282, nu=0, eta=117.347760720783,
+                  chi=90, phi=-90, unit='DEG')
+        self._check_angles_to_hkl(
+            '101', 999, 999, hkl, pos, self.wavelength, {})
+        self._check_hkl_to_angles(
+            '101', 999, 999, hkl, pos, self.wavelength, {})
+
+
+class TestFixedChiPhiPsiMode_DiamondI07SurfaceNormalHorizontal(_TestCubic):
+    """
+    The data here is taken from an experiment performed on Diamonds I07
+    beamline, obtained using Vlieg's DIF software"""
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.mock_hardware.set_lower_limit(NUNAME, 0)
+        self.mock_hardware.set_upper_limit('delta', 90)
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'a_eq_b': None}
+        self.wavelength = 1
+        self.UB = I * 2 * pi
+        self.places = 4
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+        # Set some random reference vector orientation
+        # that won't coincide with the scattering vector direction.
+        #self.mock_ubcalc.n_phi = matrix([[0.087867277], [0.906307787], [0.413383038]])
+        #self.mock_ubcalc.n_phi = matrix([[0.], [1.], [0.]])
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        self._check_angles_to_hkl(
+            '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def testHkl001(self):
+        self._check((0, 0, 1),  # betaout=30
+                    Pos(mu=30, delta=0, nu=60, eta=90, chi=0, phi=0, unit='DEG'), fails=True)
+
+    def testHkl010(self):
+        self._check((0, 1, 0),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=120, chi=0, phi=0, unit='DEG'))
+
+    def testHkl011(self):
+        self._check((0, 1, 1),  # betaout=30
+                    Pos(mu=30, delta=54.7356, nu=90, eta=125.2644, chi=0, phi=0, unit='DEG'))
+
+    def testHkl100(self):
+        self._check((1, 0, 0),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+
+    def testHkl101(self):
+        self._check((1, 0, 1),  # betaout=30
+                    Pos(mu=30, delta=54.7356, nu=90, eta=35.2644, chi=0, phi=0, unit='DEG'))
+
+    def testHkl110(self):
+        self._check((1, 1, 0),  # betaout=0
+                    Pos(mu=0, delta=90, nu=0, eta=90, chi=0, phi=0, unit='DEG'))
+
+    def testHkl11nearly0(self):
+        self.places = 3
+        self._check((1, 1, .0001),  # betaout=0
+                    Pos(mu=0.0029, delta=89.9971, nu=90.0058, eta=90, chi=0,
+                      phi=0, unit='DEG'))
+
+    def testHkl111(self):
+        self._check((1, 1, 1),  # betaout=30
+                    Pos(mu=30, delta=54.7356, nu=150, eta=99.7356, chi=0, phi=0, unit='DEG'))
+
+    def testHklover100(self):
+        self._check((1.1, 0, 0),  # betaout=0
+                    Pos(mu=0, delta=66.7340, nu=0, eta=33.3670, chi=0, phi=0, unit='DEG'))
+
+    def testHklunder100(self):
+        self._check((.9, 0, 0),  # betaout=0
+                    Pos(mu=0, delta=53.4874, nu=0, eta=26.7437, chi=0, phi=0, unit='DEG'))
+
+    def testHkl788(self):
+        self._check((.7, .8, .8),  # betaout=23.5782
+                    Pos(mu=23.5782, delta=59.9980, nu=76.7037, eta=84.2591,
+                      chi=0, phi=0, unit='DEG'))
+
+    def testHkl789(self):
+        self._check((.7, .8, .9),  # betaout=26.7437
+                    Pos(mu=26.74368, delta=58.6754, nu=86.6919, eta=85.3391,
+                      chi=0, phi=0, unit='DEG'))
+
+    def testHkl7810(self):
+        self._check((.7, .8, 1),  # betaout=30
+                    Pos(mu=30, delta=57.0626, nu=96.86590, eta=86.6739, chi=0,
+                      phi=0, unit='DEG'))
+
+
+class SkipTestFixedChiPhiPsiModeSurfaceNormalVertical(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.mock_hardware.set_lower_limit(NUNAME, 0)
+        self.constraints._constrained = {'chi': 90 * TORAD, 'phi': 0,
+                                         'a_eq_b': None}
+        self.wavelength = 1
+        self.UB = I * 2 * pi
+        self.places = 4
+
+        self.mock_hardware.set_lower_limit('mu', None)
+        self.mock_hardware.set_lower_limit('eta', None)
+        self.mock_hardware.set_lower_limit('chi', None)
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        self._check_angles_to_hkl(
+            '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def testHkl001(self):
+        self._check((0, 0, 1),  # betaout=30
+                    Pos(mu=30, delta=0, nu=60, eta=90, chi=0, phi=0, unit='DEG'), fails=True)
+
+    def testHkl010(self):
+        self._check((0, 1, 0),  # betaout=0
+                    Pos(mu=120, delta=0, nu=60, eta=0, chi=90, phi=0, unit='DEG'))
+
+    def testHkl011(self):
+        self._check((0, 1, 1),  # betaout=30
+                    Pos(mu=30, delta=54.7356, nu=90, eta=125.2644, chi=0, phi=0, unit='DEG'))
+
+    def testHkl100(self):
+        self._check((1, 0, 0),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+
+    def testHkl101(self):
+        self._check((1, 0, 1),  # betaout=30
+                    Pos(mu=30, delta=54.7356, nu=90, eta=35.2644, chi=0, phi=0, unit='DEG'))
+
+    def testHkl110(self):
+        self._check((1, 1, 0),  # betaout=0
+                    Pos(mu=0, delta=90, nu=0, eta=90, chi=0, phi=0, unit='DEG'))
+
+    def testHkl11nearly0(self):
+        self.places = 3
+        self._check((1, 1, .0001),  # betaout=0
+                    Pos(mu=0.0029, delta=89.9971, nu=90.0058, eta=90, chi=0,
+                      phi=0, unit='DEG'))
+
+    def testHkl111(self):
+        self._check((1, 1, 1),  # betaout=30
+                    Pos(mu=30, delta=54.7356, nu=150, eta=99.7356, chi=0, phi=0, unit='DEG'))
+
+    def testHklover100(self):
+        self._check((1.1, 0, 0),  # betaout=0
+                    Pos(mu=0, delta=66.7340, nu=0, eta=33.3670, chi=0, phi=0, unit='DEG'))
+
+    def testHklunder100(self):
+        self._check((.9, 0, 0),  # betaout=0
+                    Pos(mu=0, delta=53.4874, nu=0, eta=26.7437, chi=0, phi=0, unit='DEG'))
+
+    def testHkl788(self):
+        self._check((.7, .8, .8),  # betaout=23.5782
+                    Pos(mu=23.5782, delta=59.9980, nu=76.7037, eta=84.2591,
+                      chi=0, phi=0, unit='DEG'))
+
+    def testHkl789(self):
+        self._check((.7, .8, .9),  # betaout=26.7437
+                    Pos(mu=26.74368, delta=58.6754, nu=86.6919, eta=85.3391,
+                      chi=0, phi=0, unit='DEG'))
+
+    def testHkl7810(self):
+        self._check((.7, .8, 1),  # betaout=30
+                    Pos(mu=30, delta=57.0626, nu=96.86590, eta=86.6739, chi=0,
+                      phi=0, unit='DEG'))
+
+class SkipTestFixedChiPhiPsiModeSurfaceNormalVerticalI16(_TestCubic):
+    # testing with Chris N. for pre christmas 2012 i16 experiment
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.mock_hardware.set_lower_limit('nu', 0)
+        self.constraints._constrained = {'chi': 90 * TORAD, 'phi': 0,
+                                         'a_eq_b': None}
+        self.wavelength = 1
+        self.UB = I * 2 * pi
+        self.places = 4
+
+        self.mock_hardware.set_lower_limit('mu', None)
+        self.mock_hardware.set_lower_limit('eta', None)
+        self.mock_hardware.set_lower_limit('chi', None)
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+#        self._check_angles_to_hkl(
+#            '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def testHkl_1_1_0(self):
+        self._check((1, 1, 0.001),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+        #(-89.9714,  89.9570,  90.0382,  90.0143,  90.0000,  0.0000)
+
+    def testHkl_1_1_05(self):
+        self._check((1, 1, 0.5),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_1_1_1(self):
+        self._check((1, 1, 1),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+        #    (-58.6003,  42.7342,  132.9004,  106.3249,  90.0000,  0.0000
+
+    def testHkl_1_1_15(self):
+        self._check((1, 1, 1.5),  # betaout=0
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+
+
+class TestConstrain3Sample_ChiPhiEta(_TestCubic):
+
+    def setup_method(self):
+        _TestCubic.setup_method(self)
+        self.mock_hardware.set_lower_limit(NUNAME, 0)
+        self.constraints._constrained = {'chi': 90 * TORAD, 'phi': 0,
+                                         'a_eq_b': None}
+        self.wavelength = 1
+        self.UB = I * 2 * pi
+        self.places = 4
+
+        self.mock_hardware.set_lower_limit('mu', None)
+        self.mock_hardware.set_lower_limit('eta', None)
+        self.mock_hardware.set_lower_limit('chi', None)
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+        # Set some random reference vector orientation
+        # that won't coincide with the scattering vector direction.
+        #self.mock_ubcalc.n_phi = matrix([[0.087867277], [0.906307787], [0.413383038]])
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        self._check_angles_to_hkl(
+            '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def testHkl_all0_001(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0}
+        self._check((0, 0, 1),
+                    Pos(mu=30, delta=0, nu=60, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_all0_010(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0}
+        self._check((0, 1, 0),
+                    Pos(mu=120, delta=0, nu=60, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_all0_011(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0}
+        self._check((0, 1, 1),
+                    Pos(mu=90, delta=0, nu=90, eta=0, chi=0, phi=0, unit='DEG'))
+        
+    def testHkl_phi30_100(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 30 * TORAD, 'eta': 0}
+        self._check((1, 0, 0),
+                    Pos(mu=0, delta=60, nu=0, eta=0, chi=0, phi=30, unit='DEG'))
+        
+    def testHkl_eta30_100(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 30 * TORAD}
+        self._check((1, 0, 0),
+                    Pos(mu=0, delta=60, nu=0, eta=30, chi=0, phi=0, unit='DEG'))
+        
+    def testHkl_phi90_110(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 90 * TORAD, 'eta': 0}
+        self._check((1, 1, 0),
+                    Pos(mu=0, delta=90, nu=0, eta=0, chi=0, phi=90, unit='DEG'))
+        
+    def testHkl_eta90_110(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 90 * TORAD}
+        self._check((1, 1, 0),
+                    Pos(mu=0, delta=90, nu=0, eta=90, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_all0_1(self):
+        self.mock_hardware.set_upper_limit('delta', 91)
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0 * TORAD}
+        self._check((.01, .01, .1),
+                    Pos(mu=8.6194, delta=0.5730, nu=5.7607, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_all0_2(self):
+        self.mock_hardware.set_upper_limit('delta', 91)
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0 * TORAD}
+        self._check((0, 0, .1),
+                    Pos(mu=2.8660, delta=0, nu=5.7320, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_all0_3(self):
+        self.mock_hardware.set_upper_limit('delta', 91)
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0 * TORAD}
+        self._check((.1, 0, .01),
+                    Pos(mu=30.3314, delta=5.7392, nu= 0.4970, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_show_all_solutionsall0_3(self):
+        self.mock_hardware.set_upper_limit('delta', 91)
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0 * TORAD}
+        self._check((.1, 0, .01),
+                    Pos(mu=30.3314, delta=5.7392, nu= 0.4970, eta=0, chi=0, phi=0, unit='DEG'))
+        #print self.calc.hkl_to_all_angles(.1, 0, .01, 1)
+
+    def testHkl_all0_010to001(self):
+        self.constraints._constrained = {'chi': 0, 'phi': 0, 'eta': 0}
+        self._check((0, cos(4 * TORAD), sin(4 * TORAD)),
+                    Pos(mu=120-4, delta=0, nu=60, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_1(self):
+        self.wavelength = .1
+        self.constraints._constrained = {'chi': 0, 'phi': 0 * TORAD, 'eta': 0}
+        self._check((0, 0, 1),
+                    Pos(mu=2.8660, delta=0, nu=5.7320, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_2(self):
+        self.wavelength = .1
+        self.constraints._constrained = {'chi': 0, 'phi': 0 * TORAD, 'eta': 0}
+        self._check((0, 0, 1),
+                    Pos(mu=2.8660, delta=0, nu=5.7320, eta=0, chi=0, phi=0, unit='DEG'))
+
+    def testHkl_3(self):
+        self.mock_hardware.set_upper_limit('delta', 91)
+        self.wavelength = .1
+        self.constraints._constrained = {'chi': 0, 'phi': 0 * TORAD, 'eta': 0}
+        self._check((1, 0, .1),
+                    Pos(mu= 30.3314, delta=5.7392, nu= 0.4970, eta=0, chi=0, phi=0, unit='DEG'))
+
+
+
+class TestHorizontalDeltaNadeta0_JiraI16_32_failure(_BaseTest):
+    """
+    The data here is taken from a trial experiment which failed. Diamond's internal Jira: 
+    http://jira.diamond.ac.uk/browse/I16-32"""
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self.mock_hardware.set_lower_limit(NUNAME, 0)
+        
+        self.wavelength = 12.39842 / 8
+        self.UB = matrix([[ -1.46410390e+00,  -1.07335571e+00,   2.44799214e-03],
+                          [  3.94098508e-01,  -1.07091934e+00,  -6.41132943e-04],
+                          [  7.93297438e-03,   4.01315826e-03,   4.83650166e-01]])
+        self.places = 3
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False, skip_test_pair_verification=False):
+        if not skip_test_pair_verification:
+            self._check_angles_to_hkl(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def test_hkl_bisecting_works_okay_on_i16(self):
+        self.constraints._constrained = {'delta': 0, 'a_eq_b': None, 'eta': 0}
+        self._check([-1.1812112493619709, -0.71251524866987204, 5.1997083010199221],
+                    Pos(mu=26, delta=0, nu=52, eta=0, chi=45.2453, phi=186.6933-360, unit='DEG'), fails=False)
+
+    def test_hkl_psi90_works_okay_on_i16(self):
+        # This is failing here but on the live one. Suggesting some extreme sensitivity?
+        self.constraints._constrained = {'delta': 0, 'psi': -90 * TORAD, 'eta': 0}
+        self._check([-1.1812112493619709, -0.71251524866987204, 5.1997083010199221],
+                    Pos(mu=26, delta=0, nu=52, eta=0, chi=45.2453, phi=186.6933-360, unit='DEG'), fails=False)
+        
+    def test_hkl_alpha_17_9776_used_to_fail(self):
+        # This is failing here but on the live one. Suggesting some extreme sensitivity?
+        self.constraints._constrained = {'delta': 0, 'alpha': 17.9776 * TORAD, 'eta': 0}
+        self._check([-1.1812112493619709, -0.71251524866987204, 5.1997083010199221],
+                    Pos(mu=26, delta=0, nu=52, eta=0, chi=45.2453, phi=186.6933-360, unit='DEG'), fails=False)
+
+    def test_hkl_alpha_17_9776_failing_after_bigger_small(self):
+        # This is failing here but on the live one. Suggesting some extreme sensitivity?
+        self.constraints._constrained = {'delta': 0, 'alpha': 17.8776 * TORAD, 'eta': 0}
+        self._check([-1.1812112493619709, -0.71251524866987204, 5.1997083010199221],
+                    Pos(mu=25.85, delta=0, nu=52, eta=0, chi=45.2453, phi=-173.518, unit='DEG'), fails=False)
+  
+#skip_test_pair_verification
+
+def posFromI16sEuler(phi, chi, eta, mu, delta, gamma):
+    return Pos(mu, delta, gamma, eta, chi, phi, unit='DEG')
+
+
+class TestAnglesToHkl_I16Examples():
+
+    def __init__(self):
+        self.UB1 = matrix((
+           (0.9996954135095477, -0.01745240643728364, -0.017449748351250637),
+           (0.01744974835125045, 0.9998476951563913, -0.0003045864904520898),
+           (0.017452406437283505, -1.1135499981271473e-16, 0.9998476951563912))
+            ) * (2 * pi)
+        self.WL1 = 1  # Angstrom
+
+    def test_anglesToHkl_mu_0_gam_0(self):
+        pos = posFromI16sEuler(1, 1, 30, 0, 60, 0).inRadians()
+        arrayeq_(youAnglesToHkl(pos, self.WL1, self.UB1), [1, 0, 0])
+
+    def test_anglesToHkl_mu_0_gam_10(self):
+        pos = posFromI16sEuler(1, 1, 30, 0, 60, 10).inRadians()
+        arrayeq_(youAnglesToHkl(pos, self.WL1, self.UB1),
+                 [1.00379806, -0.006578435, 0.08682408])
+
+    def test_anglesToHkl_mu_10_gam_0(self):
+        pos = posFromI16sEuler(1, 1, 30, 10, 60, 0).inRadians()
+        arrayeq_(youAnglesToHkl(pos, self.WL1, self.UB1),
+                 [0.99620193, 0.0065784359, 0.08682408])
+
+    def test_anglesToHkl_arbitrary(self):
+        pos = posFromI16sEuler(1.9, 2.9, 30.9, 0.9, 60.9, 2.9).inRadians()
+        arrayeq_(youAnglesToHkl(pos, self.WL1, self.UB1),
+                 [1.01174189, 0.02368622, 0.06627361])
+
+
+class TestAnglesToHkl_I16Numerical(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+
+        self.UB = matrix((
+           (1.11143,       0,       0),
+           (      0, 1.11143,       0),
+           (      0,       0, 1.11143))
+            )
+
+        self.constraints._constrained = {'mu':0, NUNAME: 0, 'phi': 0}
+        self.wavelength = 1.
+        self.places = 6
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+        self.mock_ubcalc.n_phi = matrix([[0], [0], [1]])
+
+
+    def _check(self, testname, hkl, pos, virtual_expected={}, fails=False, skip_test_pair_verification=False):
+        if not skip_test_pair_verification:
+            self._check_angles_to_hkl(
+                testname, 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                testname, 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                testname, 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def test_hkl_to_angles_given_UB(self):
+        self._check('I16_numeric', [2, 0, 0.000001],
+                     posFromI16sEuler(0, 0.000029, 10.188639, 0, 20.377277, 0), fails=False)
+        self._check('I16_numeric', [2, 0.000001, 0],
+                     posFromI16sEuler(0, 0, 10.188667, 0, 20.377277, 0), fails=False)
+
+
+class TestAnglesToHkl_I16GaAsExample(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+
+        self.UB = matrix((
+           (-0.78935,   0.78234,   0.01191),
+           (-0.44391,  -0.46172,   0.90831),
+           ( 0.64431,   0.64034,   0.64039))
+            )
+
+        self.constraints._constrained = {'qaz': 90. * TORAD, 'alpha': 11. * TORAD, 'mu': 0.}
+        self.wavelength = 1.239842
+        self.places = 4
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False, skip_test_pair_verification=False):
+        if not skip_test_pair_verification:
+            self._check_angles_to_hkl(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles(
+                '', 999, 999, hkl, pos, self.wavelength, virtual_expected)
+
+    def test_hkl_to_angles_given_UB(self):
+        self._check([1., 1., 1.],
+                     posFromI16sEuler(10.7263, 89.8419, 11.0000, 0., 21.8976, 0.), fails=False)
+        self._check([0., 0., 2.],
+                     posFromI16sEuler(81.2389, 35.4478, 19.2083, 0., 25.3375, 0.), fails=False)
+
+
+class FourCircleI21(YouGeometry):
+    """For a diffractometer with angles:
+          delta, eta, chi, phi
+    """
+    def __init__(self, beamline_axes_transform=None):
+        YouGeometry.__init__(self, 'fourc', {'mu': 0, NUNAME: 0}, beamline_axes_transform)
+
+    def physical_angles_to_internal_position(self, physical_angle_tuple):
+        # mu, delta, nu, eta, chi, phi
+        delta_phys, eta_phys, chi_phys, phi_phys = physical_angle_tuple
+        return Pos(0, delta_phys, 0, eta_phys, 90 - chi_phys, phi_phys, 'DEG')
+
+    def internal_position_to_physical_angles(self, internal_position):
+        clone_position = internal_position.clone()
+        clone_position.changeToDegrees()
+        _, delta_phys, _, eta_phys, chi_phys, phi_phys = clone_position.totuple()
+        return delta_phys, eta_phys, 90 - chi_phys, phi_phys
+
+
+class Test_I21ExamplesUB(_BaseTest):
+    '''NOTE: copied from test.diffcalc.scenarios.session3'''
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+
+        self.i21_geometry = FourCircleI21(beamline_axes_transform = matrix('0 0 1; 0 1 0; 1 0 0'))
+        names = ['delta', 'eta', 'chi', 'phi']
+        self.mock_hardware = SimpleHardwareAdapter(names)
+        self.constraints = YouConstraintManager(self.mock_hardware)
+        self.calc = YouHklCalculator(self.mock_ubcalc, self.i21_geometry,
+                                     self.mock_hardware, self.constraints)
+
+        U = matrix(((1.0,  0., 0.),
+                    (0.0, 0.18482, -0.98277),
+                    (0.0, 0.98277,  0.18482)))
+
+        B = matrix(((1.66222,     0.0,     0.0),
+                    (    0.0, 1.66222,     0.0),
+                    (    0.0,     0.0, 0.31260)))
+
+        self.UB = U * B
+
+        self.mock_hardware.set_lower_limit('delta', 0)
+        self.mock_hardware.set_upper_limit('delta', 180.0)
+        self.mock_hardware.set_lower_limit('eta', 0)
+        self.mock_hardware.set_upper_limit('eta', 150)
+        self.mock_hardware.set_lower_limit('chi', -41)
+        self.mock_hardware.set_upper_limit('chi', 36)
+        self.mock_hardware.set_lower_limit('phi', -100)
+        self.mock_hardware.set_upper_limit('phi', 100)
+        self.mock_hardware.set_cut('eta', 0)
+        self.mock_hardware.set_cut('phi', -180)
+        self.constraints._constrained = {'psi': 10 * TORAD, 'mu': 0, NUNAME: 0}
+        self.wavelength = 12.39842 / .650
+        self.places = 5
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+        self.mock_ubcalc.n_phi = matrix([[0], [0.], [1.]])
+
+    def makes_cases(self, zrot, yrot):
+        del zrot, yrot  # not used
+        self.cases = (
+            Pair('0_0.2_0.25', (0.0, 0.2, 0.25),
+                 Pos(mu=0, delta=62.44607, nu=0, eta=28.68407,
+                     chi=90.0 - 0.44753, phi=-9.99008, unit='DEG')),
+            Pair('0.25_0.2_0.1', (0.25, 0.2, 0.1),
+                 Pos(mu=0, delta=108.03033, nu=0, eta=3.03132,
+                     chi=90 - 7.80099, phi=87.95201, unit='DEG')),
+            )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def case_generator(self):
+        zrot, yrot = 999, 999
+        for case in self.cases:
+            yield (self._check_angles_to_hkl, case.name, zrot, yrot, case.hkl,
+                   case.position, self.wavelength, {})
+            test_method = (self._check_hkl_to_angles_fails if case.fails else
+                           self._check_hkl_to_angles)
+            yield (test_method, case.name, zrot, yrot, case.hkl, case.position,
+                   self.wavelength, {})
+
+    def test_hkl_to_angles_given_UB(self):
+        self.makes_cases(None, None)  # xrot, yrot unused
+        for case_tuple in self.case_generator():
+            yield case_tuple
+
+class SkipTest_FixedAlphaMuChiSurfaceNormalHorizontal(_BaseTest):
+    '''NOTE: copied from test.diffcalc.scenarios.session3'''
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+
+        U = matrix(((-0.71022,  0.70390, 0.01071),
+                    (-0.39941, -0.41543, 0.81725),
+                    (0.57971, 0.57615,  0.57618)))
+
+        B = matrix(((1.11143,     0.0,     0.0),
+                    (    0.0, 1.11143,     0.0),
+                    (    0.0,     0.0, 1.11143)))
+
+        self.UB = U * B
+
+        self.constraints._constrained = {'alpha': 12., 'mu': 0, 'chi': 0}
+        self.wavelength = 1.
+        self.places = 5
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+        self.mock_ubcalc.n_phi = matrix([[0.], [0.], [1.]])
+
+    def makes_cases(self, zrot, yrot):
+        del zrot, yrot  # not used
+        self.cases = (
+            Pair('0_0_0.25', (2.0, 2.0,  0.),
+                 Pos(mu=0, delta=79.85393, nu=0, eta=39.92540,
+                     chi=90.0, phi=0.0, unit='DEG')),
+            #Pair('0.25_0.25_0', (0.25, 0.25, 0.0),
+            #     Pos(mu=0, delta=27.352179, nu=0, eta=13.676090,
+            #         chi=37.774500, phi=53.965500, unit='DEG')),
+            )
+        self.case_dict = {}
+        for case in self.cases:
+            self.case_dict[case.name] = case
+
+    def case_generator(self):
+        zrot, yrot = 999, 999
+        for case in self.cases:
+            yield (self._check_angles_to_hkl, case.name, zrot, yrot, case.hkl,
+                   case.position, self.wavelength, {})
+            test_method = (self._check_hkl_to_angles_fails if case.fails else
+                           self._check_hkl_to_angles)
+            yield (test_method, case.name, zrot, yrot, case.hkl, case.position,
+                   self.wavelength, {})
+
+    def test_hkl_to_angles_given_UB(self):
+        self.makes_cases(None, None)  # xrot, yrot unused
+        for case_tuple in self.case_generator():
+            yield case_tuple
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc_methods.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc_methods.py
new file mode 100644
index 0000000..9c70192
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc_methods.py	
@@ -0,0 +1,481 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import math
+from math import pi, sin, cos
+from nose.plugins.skip import SkipTest
+from nose.tools import assert_almost_equal, raises, eq_  # @UnresolvedImport
+from mock import Mock
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.hkl.you.calc import YouHklCalculator, I, \
+    _calc_angle_between_naz_and_qaz
+from test.tools import  assert_array_almost_equal, \
+    assert_matrix_almost_equal
+from diffcalc.hkl.you.geometry  import YouPosition
+from test.diffcalc.hkl.vlieg.test_calc import \
+    createMockDiffractometerGeometry, createMockHardwareMonitor, \
+    createMockUbcalc
+from test.diffcalc.test_hardware import SimpleHardwareAdapter
+from diffcalc.util import DiffcalcException
+
+from diffcalc.hkl.you.constraints import NUNAME
+
+TORAD = pi / 180
+TODEG = 180 / pi
+
+x = matrix('1; 0; 0')
+y = matrix('0; 1; 0')
+z = matrix('0; 0; 1')
+
+
+def isnan(n):
+    # math.isnan was introduced only in python 2.6 and is not in Jython (2.5.2)
+    try:
+        return math.isnan(n)
+    except AttributeError:
+        return n != n  # for Jython
+
+
+class Test_anglesToVirtualAngles():
+
+    def setup_method(self):
+        constraints = Mock()
+        constraints.is_fully_constrained.return_value = True
+        self.calc = YouHklCalculator(createMockUbcalc(None),
+                                     createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor(),
+                                     constraints)
+
+    def check_angle(self, name, expected, mu=-99, delta=99, nu=99,
+                     eta=99, chi=99, phi=99):
+        """All in degrees"""
+        pos = YouPosition(mu, delta, nu, eta, chi, phi, unit='DEG')
+        pos.changeToRadians()
+        calculated = self.calc._anglesToVirtualAngles(pos, None)[name] * TODEG
+        assert_almost_equal(calculated, expected)
+
+    # theta
+
+    def test_theta0(self):
+        self.check_angle('theta', 0, delta=0, nu=0)
+
+    def test_theta1(self):
+        self.check_angle('theta', 1, delta=2, nu=0)
+
+    def test_theta2(self):
+        self.check_angle('theta', 1, delta=0, nu=2)
+
+    def test_theta3(self):
+        self.check_angle('theta', 1, delta=-2, nu=0)
+
+    def test_theta4(self):
+        self.check_angle('theta', 1, delta=0, nu=-2)
+
+    # qaz
+
+    def test_qaz0_degenerate_case(self):
+        self.check_angle('qaz', 0, delta=0, nu=0)
+
+    def test_qaz1(self):
+        self.check_angle('qaz', 90, delta=2, nu=0)
+
+    def test_qaz2(self):
+        self.check_angle('qaz', 90, delta=90, nu=0)
+
+    def test_qaz3(self):
+        self.check_angle('qaz', 0, delta=0, nu=1,)
+
+    # Can't see one by eye
+    # def test_qaz4(self):
+    #    pos = YouPosition(delta=20*TORAD, nu=20*TORAD)#.inRadians()
+    #    assert_almost_equal(
+    #        self.calc._anglesToVirtualAngles(pos, None)['qaz']*TODEG, 45)
+
+    #alpha
+    def test_defaultReferenceValue(self):
+        # The following tests depemd on this
+        assert_matrix_almost_equal(self.calc._ubcalc.n_phi, matrix([[0], [0], [1]]))
+
+    def test_alpha0(self):
+        self.check_angle('alpha', 0, mu=0, eta=0, chi=0, phi=0)
+
+    def test_alpha1(self):
+        self.check_angle('alpha', 0, mu=0, eta=0, chi=0, phi=10)
+
+    def test_alpha2(self):
+        self.check_angle('alpha', 0, mu=0, eta=0, chi=0, phi=-10)
+
+    def test_alpha3(self):
+        self.check_angle('alpha', 2, mu=2, eta=0, chi=0, phi=0)
+
+    def test_alpha4(self):
+        self.check_angle('alpha', -2, mu=-2, eta=0, chi=0, phi=0)
+
+    def test_alpha5(self):
+        self.check_angle('alpha', 2, mu=0, eta=90, chi=2, phi=0)
+
+    #beta
+
+    def test_beta0(self):
+        self.check_angle('beta', 0, delta=0, nu=0, mu=0, eta=0, chi=0, phi=0)
+
+    def test_beta1(self):
+        self.check_angle('beta', 0, delta=10, nu=0, mu=0, eta=6, chi=0, phi=5)
+
+    def test_beta2(self):
+        self.check_angle('beta', 10, delta=0, nu=10, mu=0, eta=0, chi=0, phi=0)
+
+    def test_beta3(self):
+        self.check_angle('beta', -10, delta=0, nu=-10, mu=0, eta=0, chi=0,
+                         phi=0)
+
+    def test_beta4(self):
+        self.check_angle('beta', 5, delta=0, nu=10, mu=5, eta=0, chi=0, phi=0)
+
+    # azimuth
+    def test_naz0(self):
+        self.check_angle('naz', 0, mu=0, eta=0, chi=0, phi=0)
+
+    def test_naz1(self):
+        self.check_angle('naz', 0, mu=0, eta=0, chi=0, phi=10)
+
+    def test_naz3(self):
+        self.check_angle('naz', 0, mu=10, eta=0, chi=0, phi=10)
+
+    def test_naz4(self):
+        self.check_angle('naz', 2, mu=0, eta=0, chi=2, phi=0)
+
+    def test_naz5(self):
+        self.check_angle('naz', -2, mu=0, eta=0, chi=-2, phi=0)
+
+    #tau
+    def test_tau0(self):
+        self.check_angle('tau', 0, mu=0, delta=0, nu=0, eta=0, chi=0, phi=0)
+        #self.check_angle('tau_from_dot_product', 90, mu=0, delta=0,
+        #nu=0, eta=0, chi=0, phi=0)
+
+    def test_tau1(self):
+        self.check_angle('tau', 90, mu=0, delta=20, nu=0, eta=10, chi=0, phi=0)
+        #self.check_angle('tau_from_dot_product', 90, mu=0, delta=20,
+        #nu=0, eta=10, chi=0, phi=0)
+
+    def test_tau2(self):
+        self.check_angle('tau', 90, mu=0, delta=20, nu=0, eta=10, chi=0, phi=3)
+        #self.check_angle('tau_from_dot_product', 90, mu=0, delta=20,
+        #nu=0, eta=10, chi=0, phi=3)
+
+    def test_tau3(self):
+        self.check_angle('tau', 88, mu=0, delta=20, nu=0, eta=10, chi=2, phi=0)
+        #self.check_angle('tau_from_dot_product', 88, mu=0, delta=20,
+        #nu=0, eta=10, chi=2, phi=0)
+
+    def test_tau4(self):
+        self.check_angle('tau', 92, mu=0, delta=20, nu=0, eta=10, chi=-2,
+                         phi=0)
+        #self.check_angle('tau_from_dot_product', 92, mu=0, delta=20,
+        #nu=0, eta=10, chi=-2, phi=0)
+
+    def test_tau5(self):
+        self.check_angle('tau', 10, mu=0, delta=0, nu=20, eta=0, chi=0, phi=0)
+        #self.check_angle('tau_from_dot_product', 10, mu=0, delta=0,
+        #nu=20, eta=0, chi=0, phi=0)
+
+    #psi
+
+    def test_psi0(self):
+        pos = YouPosition(0, 0, 0, 0, 0, 0, 'DEG')
+        assert isnan(self.calc._anglesToVirtualAngles(pos, None)['psi'])
+
+    def test_psi1(self):
+        self.check_angle('psi', 90, mu=0, delta=11, nu=0, eta=0, chi=0, phi=0)
+
+    def test_psi2(self):
+        self.check_angle(
+            'psi', 100, mu=10, delta=.001, nu=0, eta=0, chi=0, phi=0)
+
+    def test_psi3(self):
+        self.check_angle(
+            'psi', 80, mu=-10, delta=.001, nu=0, eta=0, chi=0, phi=0)
+
+    def test_psi4(self):
+        self.check_angle(
+            'psi', 90, mu=0, delta=11, nu=0, eta=0, chi=0, phi=12.3)
+
+    def test_psi5(self):
+        #self.check_angle('psi', 0, mu=10, delta=.00000001,
+        #nu=0, eta=0, chi=90, phi=0)
+        pos = YouPosition(0, 0, 0, 0, 90, 0, 'DEG')
+        pos.changeToRadians()
+        assert isnan(self.calc._anglesToVirtualAngles(pos, None)['psi'])
+
+    def test_psi6(self):
+        self.check_angle(
+            'psi', 90, mu=0, delta=0.001, nu=0, eta=90, chi=0, phi=0)
+
+    def test_psi7(self):
+        self.check_angle(
+            'psi', 92, mu=0, delta=0.001, nu=0, eta=90, chi=2, phi=0)
+
+    def test_psi8(self):
+        self.check_angle(
+            'psi', 88, mu=0, delta=0.001, nu=0, eta=90, chi=-2, phi=0)
+
+
+class Test_calc_theta():
+
+    def setup_method(self):
+        self.calc = YouHklCalculator(createMockUbcalc(I * 2 * pi),
+                                     createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor(),
+                                     Mock())
+        self.e = 12.398420  # 1 Angstrom
+
+    def test_100(self):
+        h_phi = matrix([[1], [0], [0]])
+        assert_almost_equal(self.calc._calc_theta(h_phi * 2 * pi, 1) * TODEG,
+                            30)
+
+    @raises(DiffcalcException)
+    def test_too_short(self):
+        h_phi = matrix([[1], [0], [0]])
+        self.calc._calc_theta(h_phi * 0, 1)
+
+    @raises(DiffcalcException)
+    def test_too_long(self):
+        h_phi = matrix([[1], [0], [0]])
+        self.calc._calc_theta(h_phi * 2 * pi, 10)
+
+
+class Test_calc_remaining_reference_angles_given_one():
+
+    # TODO: These are very incomplete due to either totally failing inutuition
+    #       or code!
+    def setup_method(self):
+        self.calc = YouHklCalculator(createMockUbcalc(None),
+                                     createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor(),
+                                     Mock())
+
+    def check(self, name, value, theta, tau, psi_e, alpha_e, beta_e, places=7):
+        # all in deg
+        alpha, beta = self.calc._calc_remaining_reference_angles(
+            name, value * TORAD, theta * TORAD, tau * TORAD)
+        if alpha_e is not None:
+            assert_almost_equal(alpha * TODEG, alpha_e, places)
+        if beta_e is not None:
+            assert_almost_equal(beta * TODEG, beta_e, places)
+        psi_vals = list(self.calc._calc_psi(alpha, theta * TORAD, tau * TORAD))
+        if psi_e is not None:
+            assert_array_almost_equal(sorted([v * TODEG for v in psi_vals]), sorted(psi_e))
+        for psi in psi_vals:
+            print 'psi', psi * TODEG, ' alpha:', alpha * TODEG,\
+                  ' beta:', beta * TODEG
+
+    def test_psi_given0(self):
+        self.check('psi', 90, theta=10, tau=90, psi_e=[-90, 90],
+                    alpha_e=0, beta_e=0)
+
+    def test_psi_given1(self):
+        self.check('psi', 92, theta=0.001, tau=90, psi_e=[-92, 92],
+                    alpha_e=2, beta_e=-2)
+
+    def test_psi_given3(self):
+        self.check('psi', 88, theta=0.001, tau=90, psi_e=[-88, 88],
+                    alpha_e=-2, beta_e=2)
+
+    def test_psi_given4(self):
+        self.check('psi', 0, theta=0.001, tau=90, psi_e=[0,],
+                    alpha_e=-90, beta_e=90, places=2)
+
+    def test_psi_given4a(self):
+        self.check('psi', 180, theta=0.001, tau=90, psi_e=[-180, 180],
+                    alpha_e=90, beta_e=-90, places=2)
+
+    def test_psi_given5(self):
+        self.check('psi', 180, theta=0.001, tau=80,
+                   psi_e=[-180, 180], alpha_e=80, beta_e=-80, places=2)
+
+    def test_a_eq_b0(self):
+        self.check('a_eq_b', 9999, theta=0.001, tau=90,
+                   psi_e=[-90, 90], alpha_e=0, beta_e=0)
+
+    def test_alpha_given(self):
+        self.check('alpha', 2, theta=0.001, tau=90,
+                   psi_e=[-92, 92], alpha_e=2, beta_e=-2)
+
+    def test_beta_given(self):
+        self.check('beta', 2, theta=0.001, tau=90,
+                   psi_e=[-88, 88], alpha_e=-2, beta_e=2)
+#    def test_a_eq_b1(self):
+#        self.check('a_eq_b', 9999, theta=20, tau=90,
+#                   psi_e=90, alpha_e=10, beta_e=10)
+
+#    def test_psi_given0(self):
+#        self.check('psi', 90, theta=10, tau=45, psi_e=90,
+#                    alpha_e=7.0530221302831952, beta_e=7.0530221302831952)
+    
+class Test_calc_detector_angles_given_one():
+
+    def setup_method(self):
+        self.calc = YouHklCalculator(createMockUbcalc(None),
+                                     createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor(),
+                                     Mock())
+
+    def check(self, name, value, theta, delta_e, nu_e, qaz_e):
+        # all in deg
+        delta, nu, qaz = zip(*self.calc._calc_remaining_detector_angles(
+            name, value * TORAD, theta * TORAD))
+        for delta_, nu_, qaz_ in zip(delta, nu, qaz):
+            print 'delta:', delta_ * TODEG, ' nu:', nu_ * TODEG, ' qaz:', qaz_ * TODEG
+        assert_array_almost_equal([v * TODEG for v in delta], delta_e)
+        assert_array_almost_equal([v * TODEG for v in nu], nu_e)
+        if qaz_e is not None:
+            assert_array_almost_equal([v * TODEG for v in qaz], qaz_e)
+
+    def test_nu_given0(self):
+        self.check(NUNAME, 0, theta=3, delta_e=[6, -6], nu_e=[0, 0], qaz_e=[90, -90])
+
+    def test_nu_given1(self):
+        self.check(NUNAME, 10, theta=7.0530221302831952,
+                   delta_e=[10, -10], nu_e=[10, 10], qaz_e=None)
+
+    def test_nu_given2(self):
+        self.check(NUNAME, 6, theta=3, delta_e=[0,], nu_e=[6,], qaz_e=[0,])
+
+    def test_delta_given0(self):
+        self.check('delta', 0, theta=3, delta_e=[0, 0], nu_e=[6, -6], qaz_e=[0, 180])
+
+    def test_delta_given1(self):
+        self.check('delta', 10, theta=7.0530221302831952,
+                   delta_e=[10, 10], nu_e=[10, -10], qaz_e=None)
+
+    def test_delta_given2(self):
+        self.check('delta', 6, theta=3, delta_e=[6,], nu_e=[0,], qaz_e=[90,])
+
+    def test_qaz_given0(self):
+        self.check('qaz', 90, theta=3, delta_e=[6, 174], nu_e=[0, -180], qaz_e=[90, 90])
+
+    def test_qaz_given2(self):
+        self.check('qaz', 0, theta=3, delta_e=[0, 180], nu_e=[6, -174], qaz_e=[0, 0])
+
+
+class Test_calc_angle_between_naz_and_qaz():
+
+    def test1(self):
+        diff = _calc_angle_between_naz_and_qaz(
+            theta=0, alpha=0, tau=90 * TORAD)
+        assert_almost_equal(diff * TODEG, 90)
+
+    def test2(self):
+        diff = _calc_angle_between_naz_and_qaz(
+            theta=0 * TORAD, alpha=0, tau=80 * TORAD)
+        assert_almost_equal(diff * TODEG, 80)
+
+
+class Test_calc_remaining_sample_angles_given_one():
+    #_calc_remaining_detector_angles_given_one
+    def setup_method(self):
+        self.calc = YouHklCalculator(createMockUbcalc(None),
+                                     createMockDiffractometerGeometry(),
+                                     createMockHardwareMonitor(),
+                                     Mock())
+
+    def check(self, name, value, Q_lab, n_lab, Q_phi, n_phi,
+              phi_e, chi_e, eta_e, mu_e):
+        mu, eta, chi, phi = zip(*self.calc._calc_remaining_sample_angles(
+                            name, value * TORAD, Q_lab, n_lab, Q_phi, n_phi))
+        for  mu_, eta_, chi_, phi_ in zip(mu, eta, chi, phi):
+            print 'phi', phi_ * TODEG, ' chi:', chi_ * TODEG, ' eta:', eta_ * TODEG,\
+                  ' mu:', mu_ * TODEG
+        if phi_e is not None:
+            assert_array_almost_equal([v * TODEG for v in phi], phi_e)
+        if chi_e is not None:
+            assert_array_almost_equal([v * TODEG for v in chi], chi_e)
+        if eta_e is not None:
+            assert_array_almost_equal([v * TODEG for v in eta], eta_e)
+        if mu_e is not None:
+            assert_array_almost_equal([v * TODEG for v in mu], mu_e)
+
+    def test_constrain_xx_degenerate(self):
+        self.check('mu', 0, Q_lab=x, n_lab=x, Q_phi=x, n_phi=x,
+                    phi_e=[0,], chi_e=[0,], eta_e=[0,], mu_e=[0,])
+
+    def test_constrain_mu_0(self):
+        self.check('mu', 0, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[0,], chi_e=[0,], eta_e=[0,], mu_e=[0,])
+
+    def test_constrain_mu_10(self):
+        self.check('mu', 10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[90, -90], chi_e=[10, -10], eta_e=[-90, 90], mu_e=[10, 10])
+
+    def test_constrain_mu_n10(self):
+        self.check('mu', -10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[-90, 90], chi_e=[10, -10], eta_e=[90, -90], mu_e=[-10, -10])
+
+    def test_constrain_eta_10_wasfailing(self):
+        # Required the choice of a different equation
+        self.check('eta', 10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[-10, -170], chi_e=[0, 180], eta_e=[10, 10], mu_e=[0, -180])
+
+    def test_constrain_eta_n10(self):
+        self.check('eta', -10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[10, 170], chi_e=[0, 180], eta_e=[-10, -10], mu_e=[0, 180])
+
+    def test_constrain_eta_20_with_theta_20(self):
+        theta = 20 * TORAD
+        Q_lab = matrix([[cos(theta)], [-sin(theta)], [0]])
+        self.check('eta', 20, Q_lab=Q_lab, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[0, -140], chi_e=[0, 180], eta_e=[20, 20], mu_e=[0, -180])
+
+    @raises(DiffcalcException)
+    def test_constrain_chi_0_degenerate(self):
+        self.check('chi', 0, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=0, chi_e=0, eta_e=0, mu_e=0)
+
+    def test_constrain_chi_10(self):
+        self.check('chi', 10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[-90, 90], chi_e=[10, 10], eta_e=[90, -90], mu_e=[-10, 10])
+
+    def test_constrain_chi_90(self):
+        self.check('chi', 90, Q_lab=z * (-1), n_lab=x, Q_phi=x, n_phi=z,
+                    phi_e=[0, 0], chi_e=[90, 90], eta_e=[0, 0], mu_e=[-180, 0])
+
+    def test_constrain_phi_0(self):
+        self.check('phi', 0, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[0, 0], chi_e=[0, -180], eta_e=[0, 180], mu_e=[0, -180])
+
+    def test_constrain_phi_10(self):
+        self.check('phi', 10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[10, 10], chi_e=[0, -180], eta_e=[-10, 190], mu_e=[0, -180])
+
+    def test_constrain_phi_n10(self):
+        self.check('phi', -10, Q_lab=x, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[-10, -10], chi_e=[0, -180], eta_e=[10, 170], mu_e=[0, -180])
+
+    def test_constrain_phi_20_with_theta_20(self):
+        theta = 20 * TORAD
+        Q_lab = matrix([[cos(theta)], [-sin(theta)], [0]])
+        self.check('phi', 20, Q_lab=Q_lab, n_lab=z, Q_phi=x, n_phi=z,
+                    phi_e=[20, 20], chi_e=[0, -180], eta_e=[0, 180], mu_e=[0, -180])
+
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc_surface.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc_surface.py
new file mode 100644
index 0000000..d5c2f07
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_calc_surface.py	
@@ -0,0 +1,557 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+# TODO: class largely copied from test_calc
+
+from math import pi
+from mock import Mock
+from nose.plugins.skip import SkipTest
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.hkl.you.geometry import SixCircle
+from diffcalc.hkl.willmott.calc import \
+    WillmottHorizontalPosition as WillPos
+from diffcalc.hkl.you.geometry import YouPosition as YouPos
+from diffcalc.hkl.you.calc import YouUbCalcStrategy
+from test.tools import matrixeq_
+from diffcalc.ub.calc import UBCalculation
+from diffcalc.ub.crystal import CrystalUnderTest
+from diffcalc.ub.persistence import UbCalculationNonPersister
+from test.diffcalc.hkl.you.test_calc import _BaseTest
+from diffcalc.hkl.you.constraints import NUNAME
+
+TORAD = pi / 180
+TODEG = 180 / pi
+I = matrix('1 0 0; 0 1 0; 0 0 1')
+
+
+class SkipTestSurfaceNormalVerticalCubic(_BaseTest):
+
+    def setup_method(self):
+
+        _BaseTest.setup_method(self)
+        self.constraints._constrained = {'a_eq_b': None, 'mu': -pi / 2,
+                                         'eta': 0}
+        self.wavelength = 1
+        self.UB = I * 2 * pi
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        if pos is not None:
+            self._check_angles_to_hkl('', 999, 999, hkl, pos, self.wavelength,
+                                      virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails('', 999, 999, hkl, pos,
+                                            self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles('', 999, 999, hkl, pos, self.wavelength,
+                                      virtual_expected)
+
+    def testHkl001(self):
+        pos = YouPos(mu=-90, delta=60, nu=0, eta=0, chi=90 + 30, phi=-90, unit='DEG')
+        self._check((0, 0, 1), pos, {'alpha': 30, 'beta': 30})
+
+    def testHkl011(self):
+        # raise SkipTest()
+        # skipped because we can't calculate values to check against by hand
+        pos = YouPos(mu=-90, delta=90, nu=0, eta=0, chi=90 + 90, phi=-90, unit='DEG')
+        self._check((0, 1, 1), pos, {'alpha': 45, 'beta': 45})
+
+    def testHkl010fails(self):
+        self._check((0, 1, 0),
+                    None,
+                    {'alpha': 30, 'beta': 30}, fails=True)
+
+    def testHkl100fails(self):
+        self._check((1, 0, 0),
+                    None,
+                    {'alpha': 30, 'beta': 30}, fails=True)
+
+    def testHkl111(self):
+        raise SkipTest()
+        # skipped because we can't calculate values to check against by hand
+        pos = YouPos(mu=-90, delta=90, nu=0, eta=0, chi=90 + 90, phi=-90, unit='DEG')
+        self._check((1, 1, 1), pos, {'alpha': 45, 'beta': 45})
+
+
+# Primary and secondary reflections found with the help of DDIF on Diamond's
+# i07 on Jan 27 2010
+
+
+HKL0 = 2, 19, 32
+REF0 = WillPos(delta=21.975, gamma=4.419, omegah=2, phi=326.2)
+
+HKL1 = 0, 7, 22
+REF1 = WillPos(delta=11.292, gamma=2.844, omegah=2, phi=124.1)
+
+WAVELENGTH = 0.6358
+ENERGY = 12.39842 / WAVELENGTH
+
+
+# This is the version that Diffcalc comes up with ( see following test)
+U_DIFFCALC = matrix([[-0.7178876, 0.6643924, -0.2078944],
+                     [-0.6559596, -0.5455572, 0.5216170],
+                     [0.2331402, 0.5108327, 0.8274634]])
+
+
+#class WillmottHorizontalGeometry(VliegGeometry):
+#
+#    def __init__(self):
+#        VliegGeometry.__init__(self,
+#                    name='willmott_horizontal',
+#                    supported_mode_groups=[],
+#                    fixed_parameters={},
+#                    gamma_location='base'
+#                    )
+#
+#    def physical_angles_to_internal_position(self, physicalAngles):
+#        assert (len(physicalAngles) == 4), "Wrong length of input list"
+#        return WillPos(*physicalAngles)
+#
+#    def internal_position_to_physical_angles(self, internalPosition):
+#        return internalPosition.totuple()
+
+def willmott_to_you_fixed_mu_eta(pos):
+    pos = YouPos(mu=-90,
+                       delta=pos.delta,
+                       nu=pos.gamma,
+                       eta=0,
+                       chi=90 + pos.omegah,
+                       phi=-90 - pos.phi,
+                       unit='DEG')
+
+    if pos.phi > 180:
+        pos.phi -= 360
+    elif pos.phi < -180:
+        pos.phi += 360
+    return pos
+
+
+class TestUBCalculationWithWillmotStrategy_Si_5_5_12_FixedMuEta():
+
+    def setup_method(self):
+
+        hardware = Mock()
+        hardware.get_axes_names.return_value = ('m', 'd', 'n', 'e', 'c',
+                                                       'p')
+        self.ubcalc = UBCalculation(hardware, SixCircle(),
+                                    UbCalculationNonPersister(),
+                                    YouUbCalcStrategy())
+
+    def testAgainstResultsFromJan_27_2010(self):
+        self.ubcalc.start_new('test')
+        self.ubcalc.set_lattice('Si_5_5_12', 7.68, 53.48, 75.63, 90, 90, 90)
+        self.ubcalc.add_reflection(
+            HKL0[0], HKL0[1], HKL0[2], willmott_to_you_fixed_mu_eta(REF0),
+            ENERGY, 'ref0', None)
+        self.ubcalc.add_reflection(
+            HKL1[0], HKL1[1], HKL1[2], willmott_to_you_fixed_mu_eta(REF1),
+            ENERGY, 'ref1', None)
+        self.ubcalc.calculate_UB()
+        print "U: ", self.ubcalc.U
+        print "UB: ", self.ubcalc.UB
+        matrixeq_(self.ubcalc.U, U_DIFFCALC)
+
+
+class TestFixedMuEta(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self._configure_constraints()
+        self.wavelength = 0.6358
+        B = CrystalUnderTest('xtal', 7.68, 53.48,
+                             75.63, 90, 90, 90).B
+        self.UB = U_DIFFCALC * B
+        self._configure_limits()
+
+    def _configure_constraints(self):
+        self.constraints._constrained = {'alpha': 2 * TORAD, 'mu': -pi / 2,
+                                         'eta': 0}
+
+    def _configure_limits(self):
+        self.mock_hardware.set_lower_limit(NUNAME, None)
+        self.mock_hardware.set_upper_limit('delta', 90)
+        self.mock_hardware.set_lower_limit('mu', None)
+        self.mock_hardware.set_lower_limit('eta', None)
+        self.mock_hardware.set_lower_limit('chi', None)
+
+    def _convert_willmott_pos(self, willmott_pos):
+        return  willmott_to_you_fixed_mu_eta(willmott_pos)
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        self._check_angles_to_hkl('', 999, 999, hkl, pos, self.wavelength,
+                                  virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails('', 999, 999, hkl, pos,
+                                            self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles('', 999, 999, hkl, pos, self.wavelength,
+                                      virtual_expected)
+
+    def testHkl_2_19_32_found_orientation_setting(self):
+        '''Check that the or0 reflection maps back to the assumed hkl'''
+        self.places = 2
+        self._check_angles_to_hkl('', 999, 999, HKL0,
+                        self._convert_willmott_pos(REF0),
+                        self.wavelength, {'alpha': 2})
+
+    def testHkl_0_7_22_found_orientation_setting(self):
+        '''Check that the or1 reflection maps back to the assumed hkl'''
+        self.places = 0
+        self._check_angles_to_hkl('', 999, 999, HKL1,
+                        self._convert_willmott_pos(REF1),
+                        self.wavelength, {'alpha': 2})
+
+    def testHkl_2_19_32_calculated_from_DDIF(self):
+        self.places = 3
+        willpos = WillPos(delta=21.974, gamma=4.419, omegah=2, phi=-33.803)
+        self._check((2, 19, 32),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_0_7_22_calculated_from_DDIF(self):
+        self.places = 3
+        willpos = WillPos(delta=11.241801854649, gamma=-3.038407637123,
+                          omegah=2, phi=-86.56344250267)
+        self._check((0, 7, 22),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_2_m5_12_calculated_from_DDIF(self):
+        self.places = 3
+        willpos = WillPos(delta=5.224, gamma=10.415, omegah=2, phi=-1.972)
+        self._check((2, -5, 12),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_2_19_32_calculated_predicted_with_diffcalc_and_found(self):
+        willpos = WillPos(delta=21.974032376045, gamma=4.418955754003,
+                          omegah=2, phi=-33.80254)
+        self._check((2, 19, 32),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_0_7_22_calculated_predicted_with_diffcalc_and_found(self):
+        willpos = WillPos(delta=11.241801854649, gamma=-3.038407637123,
+                          omegah=2, phi=-86.563442502670)
+        self._check((0, 7, 22),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_2_m5_12_calculated_predicted_with_diffcalc_and_found(self):
+        willpos = WillPos(delta=5.223972025344, gamma=10.415435905622,
+                          omegah=2, phi=-90 + 88.02751)
+        self._check((2, -5, 12),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+
+###############################################################################
+
+def willmott_to_you_fixed_mu_chi(pos):
+    pos = YouPos(mu=-0,
+                       delta=pos.delta,
+                       nu=pos.gamma,
+                       eta=pos.omegah,
+                       chi=90,
+                       phi=-pos.phi,
+                       unit='DEG')
+    if pos.phi > 180:
+        pos.phi -= 360
+    elif pos.phi < -180:
+        pos.phi += 360
+    return pos
+
+
+class TestUBCalculationWithWillmotStrategy_Si_5_5_12_FixedMuChi():
+
+    def setup_method(self):
+
+        hardware = Mock()
+        names = 'm', 'd', 'n', 'e', 'c', 'p'
+        hardware.get_axes_names.return_value = names
+        self.ubcalc = UBCalculation(hardware, SixCircle(),
+                                    UbCalculationNonPersister(),
+                                    YouUbCalcStrategy())
+
+    def testAgainstResultsFromJan_27_2010(self):
+        self.ubcalc.start_new('test')
+        self.ubcalc.set_lattice('Si_5_5_12', 7.68, 53.48, 75.63, 90, 90, 90)
+        self.ubcalc.add_reflection(
+            HKL0[0], HKL0[1], HKL0[2], willmott_to_you_fixed_mu_chi(REF0),
+            ENERGY, 'ref0', None)
+        self.ubcalc.add_reflection(
+            HKL1[0], HKL1[1], HKL1[2], willmott_to_you_fixed_mu_chi(REF1),
+            ENERGY, 'ref1', None)
+        self.ubcalc.calculate_UB()
+        print "U: ", self.ubcalc.U
+        print "UB: ", self.ubcalc.UB
+        matrixeq_(self.ubcalc.U, U_DIFFCALC)
+
+
+class Test_Fixed_Mu_Chi(TestFixedMuEta):
+
+    def _configure_constraints(self):
+        self.constraints._constrained = {'alpha': 2 * TORAD, 'mu': 0,
+                                         'chi': pi / 2}
+
+    def _convert_willmott_pos(self, willmott_pos):
+        return  willmott_to_you_fixed_mu_chi(willmott_pos)
+
+
+def willmott_to_you_fixed_eta_chi(pos):
+    pos = YouPos(mu=pos.omegah,
+                       delta=-pos.gamma,
+                       nu=pos.delta,
+                       eta=0,
+                       chi=0,
+                       phi=-pos.phi,
+                       unit='DEG')
+    if pos.phi > 180:
+        pos.phi -= 360
+    elif pos.phi < -180:
+        pos.phi += 360
+    return pos
+
+
+class Test_Fixed_Eta_Chi(TestFixedMuEta):
+
+    def _configure_constraints(self):
+        self.constraints._constrained = {'alpha': 2 * TORAD, 'eta': 0,
+                                         'chi': 0}
+
+    def _convert_willmott_pos(self, willmott_pos):
+        return  willmott_to_you_fixed_eta_chi(willmott_pos)
+
+    def testHkl_2_19_32_found_orientation_setting(self):
+        SkipTest()
+
+    def testHkl_0_7_22_found_orientation_setting(self):
+        SkipTest()
+
+    def testHkl_2_19_32_calculated_from_DDIF(self):
+        SkipTest()
+
+    def testHkl_0_7_22_calculated_from_DDIF(self):
+        SkipTest()
+
+    def testHkl_2_m5_12_calculated_from_DDIF(self):
+        SkipTest()
+
+    def testHkl_2_19_32_calculated_predicted_with_diffcalc_and_found(self):
+        willpos = WillPos(delta=22.0332862, gamma=-4.0973643,
+                          omegah=2, phi=--64.0273584)
+        self._check((2, 19, 32),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_0_7_22_calculated_predicted_with_diffcalc_and_found(self):
+        willpos = WillPos(delta=11.2572236, gamma=-2.9800571,
+                          omegah=2, phi=-86.5634425)
+        self._check((0, 7, 22),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+    def testHkl_2_m5_12_calculated_predicted_with_diffcalc_and_found(self):
+        willpos = WillPos(delta=5.3109941, gamma=-10.3716944,
+                          omegah=2, phi=167.0041454)
+        self._check((2, -5, 12),
+                    self._convert_willmott_pos(willpos),
+                    {'alpha': 2})
+
+# Primary and secondary reflections found with the help of DDIF on Diamond's
+# i07 on Jan 28/29 2010
+
+
+Pt531_HKL0 = -1.000, 1.000, 6.0000
+Pt531_REF0 = WillPos(delta=9.3971025, gamma=16.1812303, omegah=2,
+                                  phi=-52.1392905)
+
+Pt531_HKL1 = -2.000, -1.000, 7.0000
+Pt531_REF1 = WillPos(delta=11.0126958, gamma=-11.8636128, omegah=2,
+                                  phi=40.3803393)
+Pt531_REF12 = WillPos(delta=11.0126958, gamma=11.8636128, omegah=2,
+                                  phi=-121.2155975)
+Pt531_HKL2 = 1, 1, 9
+Pt531_REF2 = WillPos(delta=14.1881617, gamma=7.7585939, omegah=2,
+                                  phi=23.0203132)
+Pt531_REF22 = WillPos(delta=14.1881617, gamma=-7.7585939, omegah=2,
+                                  phi=-183.465146)
+Pt531_WAVELENGTH = 0.6358
+
+# This is U matrix displayed by DDIF
+U_FROM_DDIF = matrix([[-0.00312594, -0.00063417, 0.99999491],
+                      [0.99999229, -0.00237817, 0.00312443],
+                      [0.00237618, 0.99999697, 0.00064159]])
+
+# This is the version that Diffcalc comes up with ( see following test)
+Pt531_U_DIFFCALC = matrix([[-0.0023763, -0.9999970, -0.0006416],
+                           [0.9999923, -0.0023783, 0.0031244],
+                           [-0.0031259, -0.0006342, 0.9999949]])
+
+
+class TestUBCalculationWithYouStrategy_Pt531_FixedMuChi():
+
+    def setup_method(self):
+
+        hardware = Mock()
+        names = 'm', 'd', 'n', 'e', 'c', 'p'
+        hardware.get_axes_names.return_value = names
+        self.ubcalc = UBCalculation(hardware, SixCircle(),
+                                    UbCalculationNonPersister(),
+                                    YouUbCalcStrategy())
+
+    def testAgainstResultsFromJan_28_2010(self):
+        self.ubcalc.start_new('test')
+        self.ubcalc.set_lattice('Pt531', 6.204, 4.806, 23.215, 90, 90, 49.8)
+
+        self.ubcalc.add_reflection(Pt531_HKL0[0], Pt531_HKL0[1], Pt531_HKL0[2],
+                                  willmott_to_you_fixed_mu_chi(Pt531_REF0),
+                                  12.39842 / Pt531_WAVELENGTH,
+                                  'ref0', None)
+        self.ubcalc.add_reflection(Pt531_HKL1[0], Pt531_HKL1[1], Pt531_HKL1[2],
+                                  willmott_to_you_fixed_mu_chi(Pt531_REF1),
+                                  12.39842 / Pt531_WAVELENGTH,
+                                  'ref1', None)
+        self.ubcalc.calculate_UB()
+        print "U: ", self.ubcalc.U
+        print "UB: ", self.ubcalc.UB
+        matrixeq_(self.ubcalc.U, Pt531_U_DIFFCALC)
+
+
+class Test_Pt531_FixedMuChi(_BaseTest):
+
+    def setup_method(self):
+        _BaseTest.setup_method(self)
+        self._configure_constraints()
+        self.wavelength = Pt531_WAVELENGTH
+        CUT = CrystalUnderTest('Pt531', 6.204, 4.806, 23.215, 90, 90, 49.8)
+        B = CUT.B
+        self.UB = Pt531_U_DIFFCALC * B
+        self._configure_limits()
+
+    def _configure_constraints(self):
+        self.constraints._constrained = {'alpha': 2 * TORAD, 'mu': 0,
+                                         'chi': pi / 2}
+
+    def _configure_limits(self):
+        self.mock_hardware.set_lower_limit(NUNAME, None)
+        #self.mock_hardware.set_lower_limit('delta', None)
+        self.mock_hardware.set_upper_limit('delta', 90)
+        self.mock_hardware.set_lower_limit('mu', None)
+        self.mock_hardware.set_lower_limit('eta', None)
+        self.mock_hardware.set_lower_limit('chi', None)
+
+    def _convert_willmott_pos(self, willmott_pos):
+        return  willmott_to_you_fixed_mu_chi(willmott_pos)
+
+    def _configure_ub(self):
+        self.mock_ubcalc.UB = self.UB
+
+    def _check(self, hkl, pos, virtual_expected={}, fails=False):
+        self._check_angles_to_hkl('', 999, 999, hkl, pos, self.wavelength,
+                                  virtual_expected)
+        if fails:
+            self._check_hkl_to_angles_fails('', 999, 999, hkl, pos,
+                                            self.wavelength, virtual_expected)
+        else:
+            self._check_hkl_to_angles('', 999, 999, hkl, pos, self.wavelength,
+                                      virtual_expected)
+
+    def testHkl_0_found_orientation_setting(self):
+        '''Check that the or0 reflection maps back to the assumed hkl'''
+        self.places = 1
+        self._check_angles_to_hkl('', 999, 999, Pt531_HKL0,
+                        self._convert_willmott_pos(Pt531_REF0),
+                        self.wavelength, {'alpha': 2})
+
+    def testHkl_1_found_orientation_setting(self):
+        '''Check that the or1 reflection maps back to the assumed hkl'''
+        self.places = 0
+        self._check_angles_to_hkl('', 999, 999, Pt531_HKL1,
+                        self._convert_willmott_pos(Pt531_REF1),
+                        self.wavelength, {'alpha': 2})
+
+    def testHkl_0_calculated_from_DDIF(self):
+        self.places = 7
+        pos_expected = self._convert_willmott_pos(Pt531_REF0)
+        self._check(Pt531_HKL0,
+                    pos_expected,
+                    {'alpha': 2})
+
+    def testHkl_1_calculated_from_DDIF(self):
+        self.places = 7
+        self._check(Pt531_HKL1,
+                    self._convert_willmott_pos(Pt531_REF1),
+                    {'alpha': 2})
+
+    def testHkl_2_calculated_from_DDIF(self):
+        self.places = 7
+        self._check(Pt531_HKL2,
+                    self._convert_willmott_pos(Pt531_REF2),
+                    {'alpha': 2})
+
+    def testHkl_2_m1_0_16(self):
+        self.places = 7
+        pos = WillPos(delta=25.7990976, gamma=-6.2413545, omegah=2,
+                                  phi=47.4624380)
+#        pos.phi -= 360
+        self._check((-1, 0, 16),
+                    self._convert_willmott_pos(pos),
+                    {'alpha': 2})
+
+
+class Test_Pt531_Fixed_Mu_eta_(Test_Pt531_FixedMuChi):
+
+    def _configure_constraints(self):
+        self.constraints._constrained = {'alpha': 2 * TORAD, 'mu': -pi / 2,
+                                         'eta': 0}
+
+    def _convert_willmott_pos(self, willmott_pos):
+        return  willmott_to_you_fixed_mu_eta(willmott_pos)
+
+    def testHkl_1_calculated_from_DDIF(self):
+        self.places = 7
+        self._check(Pt531_HKL1,
+                    self._convert_willmott_pos(Pt531_REF12),
+                    {'alpha': 2})
+
+    def testHkl_2_calculated_from_DDIF(self):
+        self.places = 7
+        self._check(Pt531_HKL2,
+                    self._convert_willmott_pos(Pt531_REF22),
+                    {'alpha': 2})
+
+    def testHkl_2_m1_0_16(self):
+        self.places = 7
+        pos = WillPos(delta=25.7990976, gamma=6.2413545, omegah=2,
+                                  phi=-47.4949600)
+#        pos.phi -= 360
+        self._check((-1, 0, 16),
+                    self._convert_willmott_pos(pos),
+                    {'alpha': 2})
+
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_constraints.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_constraints.py
new file mode 100644
index 0000000..1b185ac
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_constraints.py	
@@ -0,0 +1,575 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+
+from nose.tools import eq_  # @UnresolvedImport
+from mock import Mock
+
+from diffcalc.hkl.you.constraints import YouConstraintManager
+from diffcalc.util import DiffcalcException
+from nose.tools import raises
+from nose.tools import assert_raises  # @UnresolvedImport
+
+from diffcalc.hkl.you.constraints import NUNAME
+import diffcalc.util
+
+def joined(d1, d2):
+    d1.update(d2)
+    return d1
+
+
+class TestConstraintManager:
+
+    def setup_method(self):
+        diffcalc.util.COLOURISE_TERMINAL_OUTPUT = False
+        self.hardware_monitor = Mock()
+        self.hardware_monitor.get_position.return_value = (1.,) * 6
+        self.hardware_monitor.get_axes_names.return_value = [
+                                      'mu', 'delta', NUNAME, 'eta', 'chi', 'phi']
+        self.cm = YouConstraintManager(self.hardware_monitor)
+
+    def test_init(self):
+        eq_(self.cm.all, {})
+        eq_(self.cm.detector, {})
+        eq_(self.cm.reference, {})
+        eq_(self.cm.sample, {})
+        eq_(self.cm.naz, {})
+
+    def test_build_display_table(self):
+        self.cm.constrain('qaz')
+        self.cm.constrain('alpha')
+        self.cm.constrain('eta')
+        self.cm.set_constraint('qaz', 1.234)
+        self.cm.set_constraint('eta', 99.)
+        print '\n'.join(self.cm.build_display_table_lines())
+        eq_(self.cm.build_display_table_lines(),
+            ['    DET        REF        SAMP',
+             '    ------     ------     ------',
+             '    delta      a_eq_b     mu',
+             '    %s o-> alpha  --> eta' % NUNAME.ljust(6),
+             '--> qaz        beta       chi',
+             '    naz        psi        phi',
+             '                          mu_is_%s' % NUNAME])
+
+
+#"""
+#    DET        REF        SAMP                  Available:
+#    ======     ======     ======
+#    delta      a_eq_b     mu                    3x samp:         80 of 80
+#    nu     o-> alpha  --> eta                   2x samp and ref: chi & phi
+#--> qaz        beta       chi                                    mu & eta
+#    naz        psi        phi                                    chi=90 & mu=0
+#                          mu_is_nu              2x samp and det: 0 of 6
+#                                                3x samp:         0 of 4
+#"""[1:-1]
+
+    def test_unconstrain_okay(self):
+        eq_(self.cm.all, {})
+        self.cm.constrain('delta')
+        self.cm.constrain('mu')
+        eq_(self.cm.all, {'delta': None, 'mu': None})
+        eq_(self.cm.unconstrain('delta'), None)
+        eq_(self.cm.all, {'mu': None})
+        
+    def test_clear_constraints(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('mu')
+        self.cm.clear_constraints()
+        eq_(self.cm.all, {})
+
+    def test_unconstrain_bad(self):
+        eq_(self.cm.all, {})
+        eq_(self.cm.unconstrain('delta'), "Delta was not already constrained.")
+
+    def test_constrain_det(self, pre={}):
+        eq_(self.cm.all, pre)
+        eq_(self.cm.constrain('delta'), None)
+        eq_(self.cm.all, joined({'delta': None}, pre))
+        eq_(self.cm.constrain('delta'), 'Delta is already constrained.')
+        eq_(self.cm.all, joined({'delta': None}, pre))
+        eq_(self.cm.constrain('naz'), 'Delta constraint replaced.')
+        eq_(self.cm.all, joined({'naz': None}, pre))
+        eq_(self.cm.constrain('delta'), 'Naz constraint replaced.')
+        eq_(self.cm.all, joined({'delta': None}, pre))
+
+    def test_constrain_det_one_preexisting_ref(self):
+        self.cm.constrain('alpha')
+        self.test_constrain_det({'alpha': None})
+
+    def test_constrain_det_one_preexisting_samp(self):
+        self.cm.constrain('phi')
+        self.test_constrain_det({'phi': None})
+
+    def test_constrain_det_one_preexisting_samp_and_ref(self):
+        self.cm.constrain('alpha')
+        self.cm.constrain('phi')
+        self.test_constrain_det({'alpha': None, 'phi': None})
+
+    def test_constrain_det_two_preexisting_samp(self):
+        self.cm.constrain('chi')
+        self.cm.constrain('phi')
+        self.test_constrain_det({'chi': None, 'phi': None})
+
+    def test_constrain_det_three_preexisting_other(self):
+        self.cm.constrain('alpha')
+        self.cm.constrain('phi')
+        self.cm.constrain('chi')
+        try:
+            self.cm.constrain('delta')
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0], (
+                "Delta could not be constrained. First un-constrain one of the"
+                "\nangles alpha, chi or phi (with 'uncon')"))
+
+    def test_constrain_det_three_preexisting_samp(self):
+        self.cm.constrain('phi')
+        self.cm.constrain('chi')
+        self.cm.constrain('eta')
+        try:
+            self.cm.constrain('delta')
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Delta could not be constrained. First un-constrain one of the"
+                "\nangles eta, chi or phi (with 'uncon')")
+
+    def test_constrain_ref(self, pre={}):
+        eq_(self.cm.all, pre)
+        eq_(self.cm.constrain('alpha'), None)
+        eq_(self.cm.all, joined({'alpha': None}, pre))
+        eq_(self.cm.constrain('alpha'), 'Alpha is already constrained.')
+        eq_(self.cm.all, joined({'alpha': None}, pre))
+        eq_(self.cm.constrain('beta'), 'Alpha constraint replaced.')
+        eq_(self.cm.all, joined({'beta': None}, pre))
+
+    def test_constrain_ref_one_preexisting_det(self):
+        self.cm.constrain('delta')
+        self.test_constrain_ref({'delta': None})
+
+    def test_constrain_ref_one_preexisting_samp(self):
+        self.cm.constrain('phi')
+        self.test_constrain_ref({'phi': None})
+
+    def test_constrain_ref_one_preexisting_samp_and_det(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('phi')
+        self.test_constrain_ref({'delta': None, 'phi': None})
+
+    def test_constrain_ref_two_preexisting_samp(self):
+        self.cm.constrain('chi')
+        self.cm.constrain('phi')
+        self.test_constrain_ref({'chi': None, 'phi': None})
+
+    def test_constrain_ref_three_preexisting_other(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('phi')
+        self.cm.constrain('chi')
+        try:
+            self.cm.constrain('alpha'),
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Alpha could not be constrained. First un-constrain one of the"
+                "\nangles delta, chi or phi (with 'uncon')")
+
+    def test_constrain_ref_three_preexisting_samp(self):
+        self.cm.constrain('phi')
+        self.cm.constrain('chi')
+        self.cm.constrain('eta')
+        try:
+            self.cm.constrain('delta')
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Delta could not be constrained. First un-constrain one of the"
+                "\nangles eta, chi or phi (with 'uncon')")
+
+    def test_constrain_samp_when_one_free(self, pre={}):
+        eq_(self.cm.all, pre)
+        eq_(self.cm.constrain('phi'), None)
+        eq_(self.cm.all, joined({'phi': None}, pre))
+        eq_(self.cm.constrain('phi'), 'Phi is already constrained.')
+        eq_(self.cm.all, joined({'phi': None}, pre))
+
+    def test_constrain_samp_one_preexisting_samp(self):
+        self.cm.constrain('chi')
+        self.test_constrain_samp_when_one_free({'chi': None})
+
+    def test_constrain_samp_two_preexisting_samp(self):
+        self.cm.constrain('chi')
+        self.cm.constrain('eta')
+        self.test_constrain_samp_when_one_free({'chi': None, 'eta': None})
+
+    def test_constrain_samp_two_preexisting_other(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('alpha')
+        self.test_constrain_samp_when_one_free({'delta': None, 'alpha': None})
+
+    def test_constrain_samp_two_preexisting_one_det(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('eta')
+        self.test_constrain_samp_when_one_free({'delta': None, 'eta': None})
+
+    def test_constrain_samp_two_preexisting_one_ref(self):
+        self.cm.constrain('alpha')
+        self.cm.constrain('eta')
+        self.test_constrain_samp_when_one_free({'alpha': None, 'eta': None})
+
+    def test_constrain_samp_three_preexisting_only_one_samp(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('alpha')
+        self.cm.constrain('eta')
+        eq_(self.cm.constrain('phi'), 'Eta constraint replaced.')
+        eq_(self.cm.all, {'delta': None, 'alpha': None, 'phi': None})
+        eq_(self.cm.constrain('phi'), 'Phi is already constrained.')
+        eq_(self.cm.all, {'delta': None, 'alpha': None, 'phi': None})
+
+    def test_constrain_samp_three_preexisting_two_samp_one_det(self):
+        self.cm.constrain('delta')
+        self.cm.constrain('eta')
+        self.cm.constrain('chi')
+        try:
+            self.cm.constrain('phi')
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Phi could not be constrained. First un-constrain one of the"
+                "\nangles delta, eta or chi (with 'uncon')")
+
+    def test_constrain_samp_three_preexisting_two_samp_one_ref(self):
+        self.cm.constrain('alpha')
+        self.cm.constrain('eta')
+        self.cm.constrain('chi')
+        try:
+            self.cm.constrain('phi')
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Phi could not be constrained. First un-constrain one of the"
+                "\nangles alpha, eta or chi (with 'uncon')")
+
+    def test_constrain_samp_three_preexisting_samp(self):
+        self.cm.constrain('mu')
+        self.cm.constrain('eta')
+        self.cm.constrain('chi')
+        try:
+            self.cm.constrain('phi')
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Phi could not be constrained. First un-constrain one of the"
+                "\nangles mu, eta or chi (with 'uncon')")
+
+    def test_report_constraints_none(self):
+        eq_(self.cm.report_constraints_lines(),
+            ['!   3 more constraints required'])
+
+    def test_report_constraints_one_with_value(self):
+        self.cm.constrain(NUNAME)
+        self.cm.set_constraint(NUNAME, 9.12343)
+        eq_(self.cm.report_constraints_lines(),
+            ['!   2 more constraints required',
+             '    %s  : 9.1234' % NUNAME])
+
+    def test_report_constraints_one_with_novalue(self):
+        self.cm.constrain(NUNAME)
+        print '!   2 more constraints required\n!   %s: ---' % NUNAME
+        eq_(self.cm.report_constraints_lines(),
+            ['!   2 more constraints required',
+             '!   %s  : ---' % NUNAME])
+
+    def test_report_constraints_one_with_valueless(self):
+        self.cm.constrain('a_eq_b')
+        eq_(self.cm.report_constraints_lines(),
+            ['!   2 more constraints required',
+             '    a_eq_b'])
+
+    def test_report_constraints_one_with_two(self):
+        self.cm.constrain('naz')
+        self.cm.set_constraint('naz', 9.12343)
+        self.cm.constrain('a_eq_b')
+        eq_(self.cm.report_constraints_lines(),
+            ['!   1 more constraint required',
+             '    naz  : 9.1234',
+             '    a_eq_b'])
+
+    def test_report_constraints_one_with_three(self):
+        self.cm.constrain('naz')
+        self.cm.set_constraint('naz', 9.12343)
+        self.cm.constrain('a_eq_b')
+        self.cm.constrain('mu')
+        self.cm.set_constraint('mu', 9.12343)
+
+        eq_(self.cm.report_constraints_lines(),
+            ['    naz  : 9.1234',
+             '    a_eq_b',
+             '    mu   : 9.1234'])
+
+    def _constrain(self, *args):
+        for con in args:
+            self.cm.constrain(con)
+
+    @raises(ValueError)
+    def test_is_implemented_invalid(self):
+        self._constrain('naz')
+        self.cm.is_current_mode_implemented()
+
+    # 1 samp
+
+    def test_is_implemented_1_samp_naz(self):
+        self._constrain('naz', 'alpha', 'mu')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_1_samp_det(self):
+        self._constrain('qaz', 'alpha', 'mu')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    # 2 samp + ref
+
+    def test_is_implemented_2_samp_ref_mu_chi(self):
+        self._constrain('beta', 'mu', 'chi')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_2_samp_ref_mu90_chi0(self):
+        self._constrain('beta', 'mu', 'chi')
+        self.cm.set_constraint('mu', 0)
+        self.cm.set_constraint('chi', 90)
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_2_samp_ref_mu_eta(self):
+        self._constrain('beta', 'mu', 'eta')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_2_samp_ref_mu_phi(self):
+        self._constrain('beta', 'mu', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_2_samp_ref_eta_chi(self):
+        self._constrain('beta', 'eta', 'chi')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_2_samp_ref_eta_phi(self):
+        self._constrain('beta', 'eta', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_2_samp_ref_chi_phi(self):
+        self._constrain('beta', 'chi', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    # 2 samp + det
+
+    def test_is_implemented_2_samp_det_mu_chi(self):
+        self._constrain('qaz', 'mu', 'chi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_2_samp_det_mu_eta(self):
+        self._constrain('qaz', 'mu', 'eta')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_2_samp_det_mu_phi(self):
+        self._constrain('qaz', 'mu', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_2_samp_det_eta_chi(self):
+        self._constrain('qaz', 'eta', 'chi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_2_samp_det_eta_phi(self):
+        self._constrain('qaz', 'eta', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_2_samp_det_chi_phi(self):
+        self._constrain('qaz', 'chi', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    # 3 samp
+
+    def test_is_implemented_3_samp_no_mu(self):
+        self._constrain('eta', 'chi', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), True)
+
+    def test_is_implemented_3_samp_no_eta(self):
+        self._constrain('mu', 'chi', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_3_samp_no_chi(self):
+        self._constrain('mu', 'eta', 'phi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_is_implemented_3_samp_no_phi(self):
+        self._constrain('mu', 'eta', 'chi')
+        eq_(self.cm.is_current_mode_implemented(), False)
+
+    def test_set_fails(self):
+        try:
+            self.cm.set_constraint('not_a_constraint', object())
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0], "Could not set not_a_constraint. This is not an "
+                "available constraint.")
+
+        try:
+            self.cm.set_constraint('delta', object())
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Could not set delta. This is not currently constrained.")
+
+        self.cm.constrain('a_eq_b')
+        try:
+            self.cm.set_constraint('a_eq_b', object())
+            assert False
+        except DiffcalcException, e:
+            eq_(e.args[0],
+                "Could not set a_eq_b. This constraint takes no value.")
+
+#        self.cm.constrain('delta')
+#        self.cm.track('delta')
+#        try:
+#            self.cm.set('delta', object())
+#            assert False
+#        except DiffcalcException, e:
+#            eq_(e.args[0], ("Could not set delta as this constraint is "
+#                            "configured to track its associated\n"
+#                            "physical angle. First remove this tracking "
+#                            "(use 'untrack delta')."))
+
+    def test_set(self):
+        #"%s: %s --> %f %s"
+        self.cm.constrain('alpha')
+        eq_(self.cm.set_constraint('alpha', 1.), 'alpha : --- --> 1.0')
+        eq_(self.cm.set_constraint('alpha', 2.), 'alpha : 1.0 --> 2.0')
+
+
+
+#    def test_track_fails(self):
+#        try:
+#            self.cm.track('not_a_constraint')
+#            assert False
+#        except DiffcalcException, e:
+#            eq_(e.args[0], "Could not track not_a_constraint as this is not "
+#                "an available constraint.")
+#
+#        try:
+#            self.cm.track('delta')
+#            assert False
+#        except DiffcalcException, e:
+#            eq_(e.args[0],
+#                "Could not track delta as this is not currently constrained.")
+#
+#        self.cm.constrain('a_eq_b')
+#        try:
+#            self.cm.track('a_eq_b')
+#            assert False
+#        except DiffcalcException, e:
+#            eq_(e.args[0],
+#                "Could not track a_eq_b as this constraint takes no value.")
+#
+#        self.cm.constrain('alpha')
+#        try:
+#            self.cm.track('alpha')
+#            assert False
+#        except DiffcalcException, e:
+#            eq_(e.args[0], ("Could not configure alpha to track as this "
+#                            "constraint is not associated with a\n"
+#                            "physical angle."))
+#
+#    def test_track(self):
+#        #"%s: %s --> %f %s"
+#        self.cm.constrain('delta')
+#        eq_(self.cm.track('delta'), 'delta : --- ~~> 1.0 (tracking)')
+#        eq_(self.cm.track('delta'), 'Delta was already configured to track.')
+#        self.cm.untrack('delta')
+#        self.cm.set_constraint('delta', 2.)
+#        eq_(self.cm.track('delta'), 'delta : 2.0 ~~> 1.0 (tracking)')
+
+class TestConstraintManagerWithFourCircles:
+
+    def setup_method(self):
+        self.cm = YouConstraintManager(None, {NUNAME: 0, 'mu': 0})    
+
+    def test_init(self):
+        eq_(self.cm.all, {NUNAME: 0, 'mu': 0})
+        eq_(self.cm.detector, {NUNAME: 0})
+        eq_(self.cm.reference, {})
+        eq_(self.cm.sample, {'mu': 0})
+        eq_(self.cm.naz, {})
+
+    def test_build_initial_display_table_with_fixed_detector(self):
+        self.cm = YouConstraintManager(None, {NUNAME: 0})
+        print self.cm.build_display_table_lines()
+        eq_(self.cm.build_display_table_lines(),
+            ['    REF        SAMP',
+             '    ------     ------',
+             '    a_eq_b     mu',
+             '    alpha      eta',
+             '    beta       chi',
+             '    psi        phi'])
+        
+    def test_build_initial_display_table_with_fixed_sample(self):
+        self.cm = YouConstraintManager(None, {'mu': 0})
+        print self.cm.build_display_table_lines()
+        eq_(self.cm.build_display_table_lines(),
+            ['    DET        REF        SAMP',
+             '    ------     ------     ------',
+             '    delta      a_eq_b     eta',
+             '    %s     alpha      chi' % NUNAME.ljust(6),
+             '    qaz        beta       phi',
+             '    naz        psi'])
+        
+    def test_build_initial_display_table_for_four_circle(self):
+        self.cm = YouConstraintManager(None, {'mu': 0, NUNAME: 0})
+        print self.cm.build_display_table_lines()
+        eq_(self.cm.build_display_table_lines(),
+            ['    REF        SAMP',
+             '    ------     ------',
+             '    a_eq_b     eta',
+             '    alpha      chi',
+             '    beta       phi',
+             '    psi'])
+        
+    def test_constrain_fixed_detector_angle(self):
+        assert_raises(DiffcalcException, self.cm.constrain, 'delta')
+        assert_raises(DiffcalcException, self.cm.constrain, NUNAME)
+        assert_raises(DiffcalcException, self.cm.constrain, 'naz')
+        assert_raises(DiffcalcException, self.cm.constrain, 'qaz')
+
+    def test_unconstrain_fixed_detector_angle(self):
+        assert_raises(DiffcalcException, self.cm.unconstrain, 'delta')
+        assert_raises(DiffcalcException, self.cm.unconstrain, NUNAME)
+        assert_raises(DiffcalcException, self.cm.unconstrain, 'naz')
+        assert_raises(DiffcalcException, self.cm.unconstrain, 'qaz')
+        
+    def test_set_constrain_fixed_detector_angle(self):
+        assert_raises(DiffcalcException, self.cm.set_constraint, 'delta', 0)
+        assert_raises(DiffcalcException, self.cm.set_constraint, NUNAME, 0)
+        assert_raises(DiffcalcException, self.cm.set_constraint, 'naz', 0)
+        assert_raises(DiffcalcException, self.cm.set_constraint, 'qaz', 0)
+    
+    @raises(DiffcalcException)
+    def test_constrain_fixed_sample_angle(self):
+        self.cm.constrain('mu')
+
+    @raises(DiffcalcException)
+    def test_unconstrain_fixed_sample_angle(self):
+        self.cm.unconstrain('mu')
+
+    @raises(DiffcalcException)
+    def test_set_constrain_fixed_sample_angle(self):
+        self.cm.set_constraint('mu', 0)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_hkl.py b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_hkl.py
new file mode 100644
index 0000000..95fc904
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/hkl/you/test_hkl.py	
@@ -0,0 +1,96 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+
+from mock import Mock, call
+from diffcalc import settings
+
+import diffcalc
+from test.diffcalc.test_hardware import SimpleHardwareAdapter
+diffcalc.util.DEBUG = True
+
+
+hkl = None
+def setup_module():
+    global hkl
+    settings.hardware=SimpleHardwareAdapter([])
+    settings.geometry=Mock()
+    settings.angles_to_hkl_function=Mock()
+    settings.ubcalc_strategy=Mock()
+    settings.geometry.fixed_constraints = {}
+    
+    from diffcalc.hkl.you import hkl
+    reload(hkl)
+    
+    hkl.hklcalc = Mock()
+    hkl.hklcalc.constraints.report_constraints_lines.return_value = ['report1', 'report2']
+
+
+def test_con_with_1_constraint():
+    hkl.con('cona')
+    hkl.hklcalc.constraints.constrain.assert_called_with('cona')
+
+def test_con_with_1_constraint_with_value():
+    hkl.con('cona', 123)
+    hkl.hklcalc.constraints.constrain.assert_called_with('cona')
+    hkl.hklcalc.constraints.set_constraint.assert_called_with('cona', 123)
+
+def test_con_with_3_constraints():
+    hkl.con('cona', 'conb', 'conc')
+    hkl.hklcalc.constraints.clear_constraints.assert_called()
+    calls = [call('cona'), call('conb'), call('conc')]
+    hkl.hklcalc.constraints.constrain.assert_has_calls(calls)
+
+def test_con_with_3_constraints_first_val():
+    hkl.con('cona', 1, 'conb', 'conc')
+    hkl.hklcalc.constraints.clear_constraints.assert_called()
+    calls = [call('cona'), call('conb'), call('conc')]
+    hkl.hklcalc.constraints.constrain.assert_has_calls(calls)
+    hkl.hklcalc.constraints.set_constraint.assert_called_with('cona', 1)
+
+def test_con_with_3_constraints_second_val():
+    hkl.con('cona', 'conb', 2, 'conc')
+    hkl.hklcalc.constraints.clear_constraints.assert_called()
+    calls = [call('cona'), call('conb'), call('conc')]
+    hkl.hklcalc.constraints.constrain.assert_has_calls(calls)
+    hkl.hklcalc.constraints.set_constraint.assert_called_with('conb', 2)
+    
+def test_con_with_3_constraints_third_val():
+    hkl.con('cona', 'conb', 'conc', 3)
+    hkl.hklcalc.constraints.clear_constraints.assert_called()
+    calls = [call('cona'), call('conb'), call('conc')]
+    hkl.hklcalc.constraints.constrain.assert_has_calls(calls)
+    hkl.hklcalc.constraints.set_constraint.assert_called_with('conc', 3)
+    
+def test_con_with_3_constraints_all_vals():
+    hkl.con('cona', 1, 'conb', 2, 'conc', 3)
+    hkl.hklcalc.constraints.clear_constraints.assert_called()
+    calls = [call('cona'), call('conb'), call('conc')]
+    hkl.hklcalc.constraints.constrain.assert_has_calls(calls)
+    calls = [call('cona', 1), call('conb', 2), call('conc', 3)]
+    hkl.hklcalc.constraints.set_constraint.assert_has_calls(calls)
+    
+def test_con_messages_and_help_visually():
+    hkl.con()
+    print "**"
+    print hkl.con.__doc__
+    
+def test_con_message_display_whenn_selecting_an_unimplmented_mode():
+    hkl.hklcalc.constraints.is_fully_constrained.return_value = True
+    hkl.hklcalc.constraints.is_current_mode_implemented.return_value = False
+    hkl.con('phi', 'chi', 'eta')
diff --git a/script/test/diffcalc (copy)/test/diffcalc/scenarios.py b/script/test/diffcalc (copy)/test/diffcalc/scenarios.py
new file mode 100644
index 0000000..6365c09
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/scenarios.py	
@@ -0,0 +1,202 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from datetime import datetime
+from math import asin, sin, cos, atan2
+
+from diffcalc.ub.reflections import _Reflection
+from diffcalc.hkl.vlieg.geometry import VliegPosition
+from diffcalc.hkl.you.geometry import YouPosition
+from diffcalc.hkl.you.calc import sign
+from diffcalc.util import TORAD, TODEG
+
+
+class YouPositionScenario(YouPosition):
+    """Convert six-circle Vlieg diffractometer angles into 4S+2D You geometry"""
+    def __init__(self, alpha=None, delta=None, gamma=None, omega=None,
+                 chi=None, phi=None):
+        self.mu = alpha
+        self.eta = omega
+        self.chi = chi
+        self.phi = phi
+        self.unit = 'DEG'
+        asin_delta = asin(sin(delta*TORAD) * cos(gamma*TORAD))*TODEG  # Eq.(83)
+        vals_delta = [asin_delta, 180. - asin_delta]
+        idx, _ = min([(i, abs(delta - d)) for i, d in enumerate(vals_delta)], key=lambda x: x[1])
+        self.delta = vals_delta[idx]
+        sgn = sign(cos(self.delta * TORAD))
+        self.nu = atan2(sgn*(cos(delta*TORAD)*cos(gamma*TORAD)*sin(alpha*TORAD) + cos(alpha*TORAD)*sin(gamma*TORAD)),
+                        sgn*(cos(delta*TORAD)*cos(gamma*TORAD)*cos(alpha*TORAD) - sin(alpha*TORAD)*sin(gamma*TORAD)))*TODEG   # Eq.(84)
+
+
+class SessionScenario:
+    """
+    A test scenario. The test case must have __name, lattice and bmatrix set
+    and if umatrix is set then so must ref 1 and ref 2. Matrices should be 3*3
+    python arrays of lists and ref1 and ref2 in the format (h, k, l, position,
+    energy, tag)."""
+
+    def __init__(self):
+        self.name = None
+        self.lattice = None
+        self.bmatrix = None
+        self.ref1 = None
+        self.ref2 = None
+        self.umatrix = None
+        self.calculations = []  # CalculationScenarios
+
+    def __str__(self):
+        toReturn = "\nTestScenario:"
+        toReturn += "\n     name: " + self.name
+        toReturn += "\n  lattice:" + str(self.lattice)
+        toReturn += "\n  bmatrix:" + str(self.bmatrix)
+        toReturn += "\n     ref1:" + str(self.ref1)
+        toReturn += "\n     ref2:" + str(self.ref2)
+        toReturn += "\n  umatrix:" + str(self.umatrix)
+        return toReturn
+
+
+class CalculationScenario:
+    """
+    Used as part of a test scenario. A UB matrix appropriate for this
+    calcaultion will have been calculated or loaded
+    """
+    def __init__(self, tag, package, mode, energy, modeToTest, modeNumber):
+        self.tag = tag
+        self.package = package
+        self.mode = mode
+        self.energy = energy
+        self.wavelength = 12.39842 / energy
+        self.modeToTest = modeToTest
+        self.modeNumber = modeNumber
+        self.hklList = None  # hkl triples
+        self.posList = []
+        self.paramList = []
+
+
+def sessions(P=VliegPosition):
+    ############################ SESSION0 ############################
+    # From the dif_init.mat next to dif_dos.exe on Vlieg'session2 cd
+    #session2 = SessionScenario()
+    #session2.name = 'latt1'
+    #session2.lattice = ([4.0004, 4.0004, 2.270000, 90, 90, 90])
+    #session2.bmatrix = (((1.570639, 0, 0) ,(0.0, 1.570639, 0) ,
+    #                      (0.0, 0.0, 2.767923)))
+    #self.scenarios.append(session2)
+    
+    
+    ############################ SESSION1 ############################
+    # From b16 on 27June2008 (From Chris Nicklin)
+    
+    session1 = SessionScenario()
+    session1.name = "b16_270608"
+    session1.time = datetime.now()
+    session1.lattice = ((3.8401, 3.8401, 5.43072, 90, 90, 90))
+    session1.bmatrix = (((1.636204, 0, 0), (0, 1.636204, 0), (0, 0, 1.156971)))
+    session1.ref1 = _Reflection(1, 0, 1.0628,
+                               P(5.000, 22.790, 0.000, 1.552, 22.400, 14.255),
+                               10, 'ref1', session1.time)
+    session1.ref2 = _Reflection(0, 1, 1.0628,
+                               P(5.000, 22.790, 0.000, 4.575, 24.275, 101.320),
+                               10, 'ref2', session1.time)
+    session1.umatrix = ((0.997161, -0.062217, 0.042420),
+                   (0.062542, 0.998022, -0.006371),
+                   (-0.041940, 0.009006, 0.999080))
+    session1.ref1calchkl = (1, 0, 1.0628)  # Must match the guessed value!
+    session1.ref2calchkl = (-0.0329, 1.0114, 1.04)
+    
+    
+    ############################ SESSION2 ############################
+    # cubic crystal from bliss tutorial
+    session2 = SessionScenario()
+    session2.name = "cubic_from_bliss_tutorial"
+    session2.time = datetime.now()
+    session2.lattice = ((1.54, 1.54, 1.54, 90, 90, 90))
+    session2.ref1 = _Reflection(1, 0, 0, P(0, 60, 0, 30, 0, 0),
+                               12.39842 / 1.54, 'ref1', session2.time)
+    session2.ref2 = _Reflection(0, 1, 0, P(0, 60, 0, 30, 0, -90),
+                               12.39842 / 1.54, 'ref2', session2.time)
+    session2.bmatrix = (((4.07999, 0, 0), (0, 4.07999, 0), (0, 0, 4.07999)))
+    session2.umatrix = (((1, 0, 0), (0, -1, 0), (0, 0, -1)))
+    session2.ref1calchkl = (1, 0, 0)  # Must match the guessed value!
+    session2.ref2calchkl = (0, 1, 0)
+    # sixc-0a : fixed omega = 0
+    c = CalculationScenario('sixc-0a', 'sixc', '0', 12.39842 / 1.54, '4cBeq', 1)
+    c.alpha = 0
+    c.gamma = 0
+    c.w = 0
+    #c.hklList=((0.7, 0.9, 1.3), (1,0,0), (0,1,0), (1, 1, 0))
+    c.hklList = ((0.7, 0.9, 1.3),)
+    c.posList.append(
+        P(0.000000, 119.669750, 0.000000, 59.834875, -48.747500, 307.874983651098))
+    #c.posList.append(P(0.000000, 60.000000, 0.000000, 30.000, 0.000000, 0.000000))
+    #c.posList.append(P(0.000000, 60.000000, 0.000000, 30.000, 0.000000, -90.0000))
+    #c.posList.append(P(0.000000, 90.000000, 0.000000, 45.000, 0.000000, -45.0000))
+    session2.calculations.append(c)
+    
+    
+    ############################ SESSION3 ############################
+    # AngleCalc scenarios from SPEC sixc. using crystal and alignment
+    session3 = SessionScenario()
+    session3.name = "spec_sixc_b16_270608"
+    session3.time = datetime.now()
+    session3.lattice = ((3.8401, 3.8401, 5.43072, 90, 90, 90))
+    session3.bmatrix = (((1.636204, 0, 0), (0, 1.636204, 0), (0, 0, 1.156971)))
+    session3.umatrix = ((0.997161, -0.062217, 0.042420),
+                   (0.062542, 0.998022, -0.006371),
+                   (-0.041940, 0.009006, 0.999080))
+    session3.ref1 = _Reflection(1, 0, 1.0628,
+                               P(5.000, 22.790, 0.000, 1.552, 22.400, 14.255),
+                               12.39842 / 1.24, 'ref1', session3.time)
+    session3.ref2 = _Reflection(0, 1, 1.0628,
+                               P(5.000, 22.790, 0.000, 4.575, 24.275, 101.320),
+                               12.39842 / 1.24, 'ref2', session3.time)
+    session3.ref1calchkl = (1, 0, 1.0628)
+    session3.ref2calchkl = (-0.0329, 1.0114, 1.04)
+    # sixc-0a : fixed omega = 0
+    ac = CalculationScenario('sixc-0a', 'sixc', '0', 12.39842 / 1.24, '4cBeq', 1)
+    ac.alpha = 0
+    ac.gamma = 0
+    ac.w = 0
+    ### with 'omega_low':-90, 'omega_high':270, 'phi_low':-180, 'phi_high':180
+    ac.hklList = []
+    ac.hklList.append((0.7, 0.9, 1.3))
+    ac.posList.append(P(0.0, 27.352179, 0.000000, 13.676090, 37.774500, 53.965500))
+    ac.paramList.append({'Bin': 8.3284, 'Bout': 8.3284, 'rho': 36.5258,
+                         'eta': 0.1117, 'twotheta': 27.3557})
+    
+    ac.hklList.append((1, 0, 0))
+    ac.posList.append(P(0., 18.580230, 0.000000, 9.290115, -2.403500, 3.589000))
+    ac.paramList.append({'Bin': -0.3880, 'Bout': -0.3880, 'rho': -2.3721,
+                         'eta': -0.0089, 'twotheta': 18.5826})
+    
+    ac.hklList.append((0, 1, 0))
+    ac.posList.append(P(0., 18.580230, 0.000000, 9.290115, 0.516000, 93.567000))
+    ac.paramList.append({'Bin':  0.0833, 'Bout':  0.0833, 'rho':  0.5092,
+                         'eta': -0.0414, 'twotheta': 18.5826})
+    
+    ac.hklList.append((1, 1, 0))
+    ac.posList.append(P(0., 26.394192, 0.000000, 13.197096, -1.334500, 48.602000))
+    ac.paramList.append({'Bin': -0.3047, 'Bout': -0.3047, 'rho': -1.2992,
+                         'eta': -0.0351, 'twotheta': 26.3976})
+    
+    session3.calculations.append(ac)
+    
+    
+    ########################################################################
+    return (session1, session2, session3)
diff --git a/script/test/diffcalc (copy)/test/diffcalc/test_hardware.py b/script/test/diffcalc (copy)/test/diffcalc/test_hardware.py
new file mode 100644
index 0000000..0d9f31a
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/test_hardware.py	
@@ -0,0 +1,246 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+from diffcalc import settings
+import pytest
+
+try:
+    from gdascripts.pd.dummy_pds import DummyPD  # @UnusedImport
+except ImportError:
+    from diffcalc.gdasupport.minigda.scannable import DummyPD
+
+
+from diffcalc.gdasupport.scannable.base import ScannableGroup
+from diffcalc.gdasupport.scannable.diffractometer import \
+    DiffractometerScannableGroup
+from diffcalc.gdasupport.scannable.mock import MockMotor
+from diffcalc.hardware import DummyHardwareAdapter
+from diffcalc.hardware import HardwareAdapter
+from diffcalc.hardware import ScannableHardwareAdapter
+from nose.tools import eq_, assert_raises  # @UnresolvedImport
+from test.diffcalc.gdasupport.scannable.mockdiffcalc import MockDiffcalc
+
+
+class SimpleHardwareAdapter(HardwareAdapter):
+
+    def get_position(self):
+        return [1, 2, 3]
+
+    def get_energy(self):
+        return 1.
+
+
+class TestHardwareAdapterBase(object):
+
+    def setup_method(self):
+        self.hardware = SimpleHardwareAdapter(['a', 'b', 'c'])
+
+    def test__init__Andget_axes_names(self):
+        assert self.hardware.get_axes_names() == ('a', 'b', 'c')
+
+    def test__repr__(self):
+        print self.hardware.__repr__()
+
+    def testSetGetPosition(self):
+        pass
+
+    def testSetGetEnergyWavelength(self):
+        pass
+
+    def testget_position_by_name(self):
+        assert self.hardware.get_position_by_name('c') == 3
+        with pytest.raises(ValueError):
+            self.hardware.get_position_by_name('not an angle name')
+
+    def testLowerLimitSetAndGet(self):
+        self.hardware.set_lower_limit('a', -1)
+        self.hardware.set_lower_limit('b', -2)
+        self.hardware.set_lower_limit('c', -3)
+        with pytest.raises(ValueError):
+            self.hardware.set_lower_limit('not an angle', 1)
+        self.hardware.set_lower_limit('b', None)
+        print "Shoule print WARNING:"
+        self.hardware.set_lower_limit('b', None)
+        assert self.hardware.get_lower_limit('a') == -1
+        assert self.hardware.get_lower_limit('c') == -3
+
+    def testUpperLimitSetAndGet(self):
+        self.hardware.set_upper_limit('a', 1)
+        self.hardware.set_upper_limit('b', 2)
+        self.hardware.set_upper_limit('c', 3)
+        with pytest.raises(ValueError):
+            self.hardware.set_upper_limit('not an angle', 1)
+        self.hardware.set_upper_limit('b', None)
+        print "Shoule print WARNING:"
+        self.hardware.set_upper_limit('b', None)
+        assert self.hardware.get_upper_limit('a') == 1
+        assert self.hardware.get_upper_limit('c') == 3
+
+    def testis_position_within_limits(self):
+        self.hardware.set_upper_limit('a', 1)
+        self.hardware.set_upper_limit('b', 2)
+        self.hardware.set_lower_limit('a', -1)
+        assert self.hardware.is_position_within_limits([0, 0, 999])
+        assert self.hardware.is_position_within_limits([1, 2, 999])
+        assert self.hardware.is_position_within_limits([-1, -999, 999])
+        assert not self.hardware.is_position_within_limits([1.01, 0, 999])
+        assert not self.hardware.is_position_within_limits([0, 2.01, 999])
+        assert not self.hardware.is_position_within_limits([-1.01, 0, 999])
+
+    def testIsAxisWithinLimits(self):
+        self.hardware.set_upper_limit('a', 1)
+        self.hardware.set_upper_limit('b', 2)
+        self.hardware.set_lower_limit('a', -1)
+
+        assert self.hardware.is_axis_value_within_limits('a', 0)
+        assert self.hardware.is_axis_value_within_limits('b', 0)
+        assert self.hardware.is_axis_value_within_limits('c', 999)
+
+        assert self.hardware.is_axis_value_within_limits('a', 1)
+        assert self.hardware.is_axis_value_within_limits('b', 2)
+        assert self.hardware.is_axis_value_within_limits('c', 999)
+
+        assert self.hardware.is_axis_value_within_limits('a', -1)
+        assert self.hardware.is_axis_value_within_limits('b', -999)
+
+        assert not self.hardware.is_axis_value_within_limits('a', 1.01)
+        assert not self.hardware.is_axis_value_within_limits('b', 2.01)
+        assert not self.hardware.is_axis_value_within_limits('a', 1.01)
+
+    def setCutAndGetCuts(self):
+        self.hardware.setCut('a', 2)
+        self.hardware.setCut('b', 2)
+        self.hardware.setCut('c', 2)
+        assert self.hardware.get_cuts() == {'a': 1, 'b': 2, 'c': 3}
+        self.assertRaises(KeyError, self.hardware.setCut, 'not_a_key', 1)
+
+    def test__configureCuts(self):
+        hardware = SimpleHardwareAdapter(['a', 'b', 'c'])
+        assert hardware.get_cuts() == {'a': -180, 'b': -180, 'c': -180}
+        hardware = SimpleHardwareAdapter(['a', 'phi', 'c'])
+        assert hardware.get_cuts() == {'a': -180, 'phi': 0, 'c': -180}
+
+    def test__configureCutsWithDefaults(self):
+        hardware = SimpleHardwareAdapter(['a', 'b', 'c'], {'a': 1, 'b': 2})
+        assert hardware.get_cuts() == {'a': 1, 'b': 2, 'c': -180}
+        hardware = SimpleHardwareAdapter(['a', 'phi', 'c'],
+                                               {'a': 1, 'phi': 2})
+        assert hardware.get_cuts() == {'a': 1, 'phi': 2, 'c': -180}
+        with pytest.raises(KeyError):
+            SimpleHardwareAdapter(['a', 'b', 'c'], {'a': 1, 'not_a_key': 2})
+
+    def testCut(self):
+        assert self.hardware.cut_angles((1, 2, 3)) == (1, 2, 3)
+        assert self.hardware.cut_angles((-181, 0, 181)) == (179, 0, -179)
+        assert self.hardware.cut_angles((-180, 0, 180,)) == (-180, 0, 180)
+        assert self.hardware.cut_angles((-360, 0, 360)) == (0, 0, 0)
+
+
+class TestHardwareCommands():
+
+    def setup_method(self):
+        self.hardware = SimpleHardwareAdapter(['a', 'b', 'c'])
+        settings.hardware = self.hardware
+        from diffcalc import hardware
+        reload(hardware)
+        self.commands = hardware
+
+    def testSetcut(self):
+        print "*******"
+        self.commands.setcut()
+        print "*******"
+        self.commands.setcut('a')
+        print "*******"
+        self.commands.setcut('a', -181)
+        print "*******"
+        eq_(self.hardware.get_cuts()['a'], -181)
+        assert_raises(
+            ValueError, self.commands.setcut, 'a', 'not a number')
+        assert_raises(
+            KeyError, self.commands.setcut, 'not an axis', 1)
+
+    def test_set_lim(self):
+        self.commands.setmin('a', -1)
+        print "*******"
+        self.commands.setmin()
+        print "*******"
+        self.commands.setmax()
+        print "*******"
+
+
+class TestDummyHardwareAdapter(object):
+
+    def setup_method(self):
+        self.hardware = DummyHardwareAdapter(
+            ['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
+
+    def test__init__(self):
+        assert self.hardware.get_position() == [0.] * 6
+        assert self.hardware.get_energy() == 12.39842
+        assert self.hardware.get_wavelength() == 1.
+        assert (self.hardware.get_axes_names()
+                == ('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
+
+    def test__repr__(self):
+        print self.hardware.__repr__()
+
+    def testSetGetPosition(self):
+        pass
+
+    def testSetGetEnergyWavelength(self):
+        pass
+
+    def testget_position_by_name(self):
+        self.hardware.position = [1., 2., 3., 4., 5., 6.]
+        assert self.hardware.get_position_by_name('gamma') == 3
+        with pytest.raises(ValueError):
+            self.hardware.get_position_by_name('not an angle name')
+
+
+def createDummyAxes(names):
+    result = []
+    for name in names:
+        result.append(DummyPD(name))
+    return result
+
+
+class TestGdaHardwareMonitor(object):
+
+    def setup_method(self):
+        dummy = createDummyAxes(['a', 'b', 'c', 'd', 'e', 'f'])
+        self.grp = ScannableGroup('grp', dummy)
+        self.diffhw = DiffractometerScannableGroup('sixc', MockDiffcalc(6),
+                                                   self.grp)
+        self.energyhw = MockMotor()
+        self.hardware = ScannableHardwareAdapter(self.diffhw, self.energyhw)
+
+    def test__init__Andget_axes_names(self):
+        assert self.hardware.get_axes_names() == ('a', 'b', 'c', 'd', 'e', 'f')
+
+    def testGetPosition(self):
+        self.diffhw.asynchronousMoveTo((1, 2, 3, 4, 5, 6))
+        assert self.hardware.get_position() == [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
+
+    def testGetEnergy(self):
+        self.energyhw.asynchronousMoveTo(1.0)
+        assert self.hardware.get_energy() == 1.0
+
+    def testGetWavelength(self):
+        self.energyhw.asynchronousMoveTo(1.0)
+        assert self.hardware.get_wavelength() == 12.39842 / 1.0
diff --git a/script/test/diffcalc (copy)/test/diffcalc/test_utils.py b/script/test/diffcalc (copy)/test/diffcalc/test_utils.py
new file mode 100644
index 0000000..3ff31da
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/test_utils.py	
@@ -0,0 +1,127 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+from diffcalc.hkl.vlieg.geometry import VliegPosition
+from diffcalc.util import MockRawInput, \
+    getInputWithDefault, differ, nearlyEqual, degreesEquivilant
+import diffcalc.util  # @UnusedImport
+import pytest
+
+
+class TestUtils(object):
+
+    def testMockRawInput(self):
+        raw_input = MockRawInput('a')  # @ReservedAssignment
+        assert raw_input('?') == 'a'
+
+        raw_input = MockRawInput(['a', '1234', '1 2 3'])  # @ReservedAssignment
+        assert raw_input('?') == 'a'
+        assert raw_input('?') == '1234'
+        assert raw_input('?') == '1 2 3'
+        with pytest.raises(IndexError):
+            raw_input('?')
+
+        raw_input = MockRawInput(1)  # @ReservedAssignment
+        with pytest.raises(TypeError):
+            raw_input('?')
+
+    def testGetInputWithDefaultWithStrings(self):
+        diffcalc.util.raw_input = MockRawInput('reply')
+        print">>>"
+        assert getInputWithDefault('enter a thing', 'default') == 'reply'
+        print">>>"
+        diffcalc.util.raw_input = MockRawInput('')
+        assert getInputWithDefault('enter a thing', 'default') == 'default'
+        print">>>"
+        diffcalc.util.raw_input = MockRawInput('1.23 1 a')
+        assert getInputWithDefault('enter a thing', 'default') == '1.23 1 a'
+
+    def testGetInputWithDefaultWithNumbers(self):
+        diffcalc.util.raw_input = MockRawInput('')
+        assert getInputWithDefault('enter a thing', 1) == 1.0
+
+        diffcalc.util.raw_input = MockRawInput('')
+        assert getInputWithDefault('enter a thing', 1.23) == 1.23
+
+        diffcalc.util.raw_input = MockRawInput('1')
+        assert getInputWithDefault('enter a thing', 'default') == 1.0
+
+        diffcalc.util.raw_input = MockRawInput('1.23')
+        assert getInputWithDefault('enter a thing', 'default') == 1.23
+
+    def testGetInputWithDefaultWithLists(self):
+        diffcalc.util.raw_input = MockRawInput('')
+        assert (getInputWithDefault('enter a thing', (1, 2.0, 3.1))
+                == (1.0, 2.0, 3.1))
+
+        diffcalc.util.raw_input = MockRawInput('1 2.0 3.1')
+        assert getInputWithDefault('enter a thing', 'default') == [1.0, 2.0, 3.1]
+
+    def testDiffer(self):
+        assert not differ([1., 2., 3.], [1., 2., 3.], .0000000000000001)
+        assert not differ(1, 1.0, .000000000000000001)
+        assert (differ([2., 4., 6.], [1., 2., 3.], .1)
+                == '(2.0, 4.0, 6.0)!=(1.0, 2.0, 3.0)')
+
+        assert not differ(1., 1.2, .2)
+        assert differ(1., 1.2, .1999999999999) == '1.0!=1.2'
+        assert not differ(1., 1.2, 1.20000000000001)
+
+    def testNearlyEqual(self):
+        assert nearlyEqual([1, 2, 3], [1, 2, 3], .000000000000000001)
+        assert nearlyEqual(1, 1.0, .000000000000000001)
+        assert not nearlyEqual([2, 4, 6], [1, 2, 3], .1)
+
+        assert nearlyEqual(1, 1.2, .2)
+        assert not nearlyEqual(1, 1.2, .1999999999999)
+        assert nearlyEqual(1, 1.2, 1.20000000000001)
+
+    def testDegreesEqual(self):
+        tol = .001
+        assert degreesEquivilant(1, 1, tol)
+        assert degreesEquivilant(1, -359, tol)
+        assert degreesEquivilant(359, -1, tol)
+        assert not degreesEquivilant(1.1, 1, tol)
+        assert not degreesEquivilant(1.1, -359, tol)
+        assert not degreesEquivilant(359.1, -1, tol)
+
+
+class TestPosition(object):
+
+    def testCompare(self):
+        # Test the compare method
+        pos1 = VliegPosition(1, 2, 3, 4, 5, 6)
+        pos2 = VliegPosition(1.1, 2.1, 3.1, 4.1, 5.1, 6.1)
+
+        assert pos1 == pos1
+        assert pos1 != pos2
+
+    def testNearlyEquals(self):
+        pos1 = VliegPosition(1, 2, 3, 4, 5, 6)
+        pos2 = VliegPosition(1.1, 2.1, 3.1, 4.1, 5.1, 6.1)
+        assert pos1.nearlyEquals(pos2, 0.11)
+        assert not pos1.nearlyEquals(pos2, 0.1)
+
+    def testClone(self):
+        pos = VliegPosition(1, 2, 3, 4., 5., 6.)
+        copy = pos.clone()
+        assert pos == copy
+        pos.alpha = 10
+        pos.omega = 4.1
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/__init__.py b/script/test/diffcalc (copy)/test/diffcalc/ub/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation.py
new file mode 100644
index 0000000..44cd7ce
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation.py	
@@ -0,0 +1,174 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from diffcalc.hkl.you.calc import YouUbCalcStrategy
+from diffcalc.hkl.you.geometry import SixCircle, YouPosition
+from diffcalc.ub.calc import UBCalculation
+from diffcalc.ub.persistence import UBCalculationJSONPersister
+from math import pi
+from mock import Mock
+from nose.tools import eq_
+from test.tools import matrixeq_
+import tempfile
+import datetime
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+
+
+def posFromI16sEuler(phi, chi, eta, mu, delta, gamma):
+    return YouPosition(mu, delta, gamma, eta, chi, phi, unit='DEG')
+
+UB1 = matrix(
+    ((0.9996954135095477, -0.01745240643728364, -0.017449748351250637),
+     (0.01744974835125045, 0.9998476951563913, -0.0003045864904520898),
+     (0.017452406437283505, -1.1135499981271473e-16, 0.9998476951563912))
+    ) * (2 * pi)
+
+EN1 = 12.39842
+REF1a = posFromI16sEuler(1, 1, 30, 0, 60, 0)
+REF1b = posFromI16sEuler(1, 91, 30, 0, 60, 0)
+
+
+class TestUBCalculationWithYouStrategy():
+    """Testing the math only here.
+    """
+
+    def setup_method(self):
+        
+        self.tempdir = tempfile.mkdtemp()
+
+        geometry = SixCircle()  # pass through
+        hardware = Mock()
+        names = 'm', 'd', 'n', 'e', 'c', 'p'
+        hardware.get_axes_names.return_value = names
+        self.tmpdir = tempfile.mkdtemp()
+        print self.tmpdir
+        self.ubcalc = UBCalculation(hardware,
+                                    geometry,
+                                    UBCalculationJSONPersister(self.tmpdir),
+                                    YouUbCalcStrategy())
+
+    def testAgainstI16Results(self):
+        self.ubcalc.start_new('cubcalc')
+        self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
+        self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
+        self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
+        matrixeq_(self.ubcalc.UB, UB1)
+        
+    def test_save_and_restore_empty_ubcalc_with_one_already_started(self):
+        NAME = 'test_save_and_restore_empty_ubcalc_with_one_already_started'
+        self.ubcalc.start_new(NAME)
+        self.ubcalc.start_new(NAME)
+    
+    
+    def test_save_and_restore_empty_ubcalc(self):
+        NAME = 'test_save_and_restore_empty_ubcalc'
+        self.ubcalc.start_new(NAME)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        eq_(self.ubcalc.name, NAME)
+        
+    def test_save_and_restore_ubcalc_with_lattice(self):
+        NAME = 'test_save_and_restore_ubcalc_with_lattice'
+        self.ubcalc.start_new(NAME)
+        self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        eq_(self.ubcalc._state.crystal.getLattice(), ('latt', 1, 1, 1, 90, 90, 90))
+        
+    def test_save_and_restore_ubcalc_with_reflections(self):
+        NAME = 'test_save_and_restore_ubcalc_with_reflections'
+        self.ubcalc.start_new(NAME)
+        now = datetime.datetime.now()
+        self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', now)
+        self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', now)
+        self.ubcalc.add_reflection(0, 0, 1.5, REF1b, EN1, '001_5', now)
+        ref1 = self.ubcalc.get_reflection(1)
+        ref2 = self.ubcalc.get_reflection(2)
+        ref3 = self.ubcalc.get_reflection(3)
+        eq_(self.ubcalc.get_reflection(1), ref1)
+        eq_(self.ubcalc.get_reflection(2), ref2)
+        eq_(self.ubcalc.get_reflection(3), ref3)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        eq_(self.ubcalc.get_reflection(1), ref1)
+        eq_(self.ubcalc.get_reflection(2), ref2)
+        eq_(self.ubcalc.get_reflection(3), ref3)
+        
+    def test_save_and_restore_ubcalc_with_UB_from_two_ref(self):
+        NAME = 'test_save_and_restore_ubcalc_with_UB_from_two_ref'
+        self.ubcalc.start_new(NAME)
+        self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
+        self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
+        self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
+        matrixeq_(self.ubcalc.UB, UB1)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        matrixeq_(self.ubcalc.UB, UB1)
+        
+    def test_save_and_restore_ubcalc_with_UB_from_one_ref(self):
+        NAME = 'test_save_and_restore_ubcalc_with_UB_from_one_ref'
+        self.ubcalc.start_new(NAME)
+        self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
+        self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
+        self.ubcalc.calculate_UB_from_primary_only()
+        matrixeq_(self.ubcalc.UB, UB1,  places=2)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        matrixeq_(self.ubcalc.UB, UB1,  places=2)
+
+    def test_save_and_restore_ubcalc_with_manual_ub(self):
+        NAME = 'test_save_and_restore_ubcalc_with_manual_ub'
+        UB = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        self.ubcalc.start_new(NAME)
+        self.ubcalc.set_UB_manually(UB)
+        matrixeq_(self.ubcalc.UB, UB)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        matrixeq_(self.ubcalc.UB, UB)
+
+    def test_save_and_restore_ubcalc_with_manual_u(self):
+        NAME = 'test_save_and_restore_ubcalc_with_manual_u'
+        U = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        self.ubcalc.start_new(NAME)
+        self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
+        self.ubcalc.set_U_manually(U)
+        matrixeq_(self.ubcalc.UB, U * 2 * pi)
+        
+        self.ubcalc.start_new(NAME + '2')
+        self.ubcalc.load(NAME)
+        
+        matrixeq_(self.ubcalc.UB, U * 2 * pi)
+
+
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation_vlieg.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation_vlieg.py
new file mode 100644
index 0000000..6292332
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation_vlieg.py	
@@ -0,0 +1,380 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+from datetime import datetime
+from math import cos, sin, pi
+
+from mock import Mock
+from nose.tools import raises
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry
+from diffcalc.hkl.vlieg.geometry import VliegPosition as Pos
+from test.tools import matrixeq_, mneq_
+from diffcalc.ub.calc import UBCalculation
+from diffcalc.ub.persistence import UbCalculationNonPersister
+from diffcalc.util import DiffcalcException
+from diffcalc.hkl.vlieg.calc import VliegUbCalcStrategy
+from test.diffcalc import scenarios
+
+I = matrix('1 0 0; 0 1 0; 0 0 1')
+TORAD = pi / 180
+
+
+
+class TestUBCalculationWithSixCircleGammaOnArm(object):
+
+    def setup_method(self):
+        self.geometry = SixCircleGammaOnArmGeometry()
+        mock_hardware = Mock()
+        mock_hardware.get_axes_names.return_value = ('a', 'd', 'g', 'o', 'c', 'p')
+        self.ubcalc = UBCalculation(
+            mock_hardware, self.geometry, UbCalculationNonPersister(),
+            VliegUbCalcStrategy())
+        self.time = datetime.now()
+
+### State ###
+
+    def testNewCalculation(self):
+        self.ubcalc.start_new('testcalc')
+        assert self.ubcalc.name, 'testcalc' == "Name not set by newCalcualtion"
+
+    @raises(DiffcalcException)
+    def testNewCalculationHasNoU(self):
+        self.ubcalc.start_new('testcalc')
+        print self.ubcalc.U
+
+    @raises(DiffcalcException)
+    def testNewCalculationHasNoUB(self):
+        self.ubcalc.start_new('testcalc')
+        print self.ubcalc.UB
+
+### Lattice ###
+
+    def testSetLattice(self):
+        # Not much to test, just make sure no exceptions
+        self.ubcalc.start_new('testcalc')
+        self.ubcalc.set_lattice('testlattice', 4.0004, 4.0004, 2.27, 90, 90, 90)
+
+### Calculations ###
+
+    def testset_U_manually(self):
+
+        # Test the calculations with U=I
+        U = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+        for sess in scenarios.sessions():
+            self.setup_method()
+            self.ubcalc.start_new('testcalc')
+            self.ubcalc.set_lattice(sess.name, *sess.lattice)
+            self.ubcalc.set_U_manually(U)
+            # Check the U matrix
+            mneq_(self.ubcalc.U, matrix(U), 4,
+                  note="wrong U after manually setting U")
+
+            # Check the UB matrix
+            if sess.bmatrix is None:
+                continue
+            print "U: ", U
+            print "actual ub: ", self.ubcalc.UB.tolist()
+            print " desired b: ", sess.bmatrix
+            mneq_(self.ubcalc.UB, matrix(sess.bmatrix), 4,
+                  note="wrong UB after manually setting U")
+
+    @raises(DiffcalcException)
+    def testGetUMatrix(self):
+        self.ubcalc.start_new('testcalc')
+        print self.ubcalc.U
+
+    @raises(DiffcalcException)
+    def testGetUBMatrix(self):
+        self.ubcalc.start_new('testcalc')
+        print self.ubcalc.UB
+
+    def testCalculateU(self):
+
+        for sess in scenarios.sessions():
+            self.setup_method()
+            self.ubcalc.start_new('testcalc')
+            # Skip this test case unless it contains a umatrix
+            if sess.umatrix is None:
+                continue
+
+            self.ubcalc.set_lattice(sess.name, *sess.lattice)
+            ref1 = sess.ref1
+            ref2 = sess.ref2
+            t = sess.time
+            self.ubcalc.add_reflection(
+                ref1.h, ref1.k, ref1.l, ref1.pos, ref1.energy, ref1.tag, t)
+            self.ubcalc.add_reflection(
+                ref2.h, ref2.k, ref2.l, ref2.pos, ref2.energy, ref2.tag, t)
+            self.ubcalc.calculate_UB()
+            returned = self.ubcalc.U.tolist()
+            print "*Required:"
+            print sess.umatrix
+            print "*Returned:"
+            print returned
+            mneq_(self.ubcalc.U, matrix(sess.umatrix), 4,
+                  note="wrong U calulated for sess.name=" + sess.name)
+
+    def test__str__(self):
+        sess = scenarios.sessions()[0]
+        print "***"
+        print self.ubcalc.__str__()
+
+        print "***"
+        self.ubcalc.start_new('test')
+        print self.ubcalc.__str__()
+
+        print "***"
+        self.ubcalc.set_lattice(sess.name, *sess.lattice)
+        print self.ubcalc.__str__()
+
+        print "***"
+        ref1 = sess.ref1
+        ref2 = sess.ref2
+        t = sess.time
+        self.ubcalc.add_reflection(
+            ref1.h, ref1.k, ref1.l, ref1.pos, ref1.energy, ref1.tag, t)
+        self.ubcalc.add_reflection(
+            ref2.h, ref2.k, ref2.l, ref2.pos, ref2.energy, ref2.tag, t)
+        print self.ubcalc.__str__()
+
+        print "***"
+        self.ubcalc.calculate_UB()
+        print self.ubcalc.__str__()
+
+
+def x_rotation(mu_or_alpha):
+    mu_or_alpha *= TORAD
+    return matrix(((1, 0, 0),
+                   (0, cos(mu_or_alpha), -sin(mu_or_alpha)),
+                   (0, sin(mu_or_alpha), cos(mu_or_alpha))))
+
+
+def y_rotation(chi):
+    chi *= TORAD
+    return matrix(((cos(chi), 0, sin(chi)),
+                   (0, 1, 0),
+                   (-sin(chi), 0, cos(chi))))
+
+
+def z_rotation(th):
+    eta = -th * TORAD
+    return matrix(((cos(eta), sin(eta), 0),
+                   (-sin(eta), cos(eta), 0),
+                   (0, 0, 1)))
+
+CUBIC_EN = 12.39842
+CUBIC = (1, 1, 1, 90, 90, 90)
+ROT = 29
+
+
+class TestUBCalcWithCubic(object):
+
+    def setup_method(self):
+        print "TestUBCalcWithCubic.setup_method"
+        hardware = Mock()
+        hardware.get_axes_names.return_value = \
+            ('a', 'd', 'g', 'o', 'c', 'p')
+        self.ubcalc = UBCalculation(hardware,
+                                    SixCircleGammaOnArmGeometry(),
+                                    UbCalculationNonPersister(),
+                                    VliegUbCalcStrategy())
+        self.ubcalc.start_new('xtalubcalc')
+        self.ubcalc.set_lattice("xtal", *CUBIC)
+        self.energy = CUBIC_EN
+
+    def addref(self, hklref):
+        hkl, position = hklref
+        now = datetime.now()
+        self.ubcalc.add_reflection(
+            hkl[0], hkl[1], hkl[2], position, self.energy, "ref", now)
+
+
+class TestUBCalcWithCubicTwoRef(TestUBCalcWithCubic):
+
+    def check(self, testname, hklref1, hklref2, expectedUMatrix):
+        self.addref(hklref1)
+        self.addref(hklref2)
+        matrixeq_(expectedUMatrix, self.ubcalc.U)
+
+    def test_with_squarely_mounted(self):
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0, phi=0))
+        lref = ((0, 0, 1),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90, phi=0))
+        pairs = (("hl", href, lref, I),
+                 ("lh", lref, href, I))
+        for testname, ref1, ref2, u in pairs:
+            yield self.check, testname, ref1, ref2, u
+
+    def test_with_x_mismount(self):
+        U = x_rotation(ROT)
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0, phi=0))
+        kref = ((0, 1, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30 - ROT + 90, chi=90,
+                    phi=0))
+        lref = ((0, 0, 1),
+                Pos(alpha=0, delta=60, gamma=0, omega=30 - ROT, chi=90, phi=0))
+        pairs = (("hk", href, kref, U),
+                 ("hl", href, lref, U),
+                 ("kh", kref, href, U),
+                 ("kl", kref, lref, U),
+                 ("lk", lref, kref, U),
+                 ("lh", lref, href, U))
+        for testname, ref1, ref2, u in pairs:
+            yield self.check, testname, ref1, ref2, u
+
+    def test_with_y_mismount(self):
+        U = y_rotation(ROT)
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0 - ROT, phi=0))
+        lref = ((0, 0, 1),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90 - ROT, phi=0))
+        pairs = (("hl", href, lref, U),
+                 ("lh", lref, href, U))
+        for testname, ref1, ref2, u in pairs:
+            yield self.check, testname, ref1, ref2, u
+
+    def test_with_z_mismount(self):
+        U = z_rotation(ROT)
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0, phi=0 + ROT))
+        lref = ((0, 0, 1),  # phi degenerate
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90, phi=67))
+        pairs = (("hl", href, lref, U),
+                 ("lh", lref, href, U))
+        for testname, ref1, ref2, u in pairs:
+            yield self.check, testname, ref1, ref2, u
+
+    def test_with_zy_mismount(self):
+        U = z_rotation(ROT) * y_rotation(ROT)
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0 - ROT,
+                    phi=0 + ROT))
+        lref = ((0, 0, 1),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90 - ROT,
+                    phi=ROT))  # chi degenerate
+        pairs = (("hl", href, lref, U),
+                 ("lh", lref, href, U))
+        for testname, ref1, ref2, u in pairs:
+            yield self.check, testname, ref1, ref2, u
+
+
+class TestUBCalcWithcubicOneRef(TestUBCalcWithCubic):
+
+    def check(self, testname, hklref, expectedUMatrix):
+        print testname
+        self.addref(hklref)
+        self.ubcalc.calculate_UB_from_primary_only()
+        matrixeq_(expectedUMatrix, self.ubcalc.U)
+
+    def test_with_squarely_mounted(self):
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0, phi=0))
+        href_b = ((1, 0, 0),
+                  Pos(alpha=0, delta=60, gamma=0, omega=30 + 90, chi=90,
+                      phi=-90))
+        lref = ((0, 0, 1),  # degenerate in phi
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90, phi=67))
+        pairs = (("h", href, I),
+                 ("hb", href_b, I),
+                 ("l", lref, I))
+        for testname, ref, u in pairs:
+            yield self.check, testname, ref, u
+
+    def test_with_x_mismount_h(self):
+        U = x_rotation(ROT)
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0, phi=0))
+        self.check("h", href, I)
+        
+    def test_with_x_mismount_k(self):
+        U = x_rotation(ROT)
+        kref = ((0, 1, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30 - ROT + 90, chi=90,
+                    phi=0))
+        self.check("k", kref, U)
+        
+    def test_with_x_mismount_l(self):
+        U = x_rotation(ROT)
+        lref = ((0, 0, 1),
+                Pos(alpha=0, delta=60, gamma=0, omega=30 - ROT, chi=90, phi=0))
+        self.check("l", lref, U)
+
+    def test_with_y_mismount_h(self):
+        U = y_rotation(ROT)
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0 - ROT, phi=0))
+        self.check("h", href, U)
+
+    def test_with_y_mismount_k(self):
+        U = y_rotation(ROT)
+        kref = ((0, 1, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30 + 90, chi=90, phi=0))
+        self.check("k", kref, I)  # TODO: can't pass - word instructions
+
+    def test_with_y_mismount_l(self):
+        U = y_rotation(ROT)
+        lref = ((0, 0, 1),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90 - ROT, phi=0))
+        self.check("l", lref, U)
+
+    def test_with_z_mismount_h(self):
+        U = z_rotation(ROT)
+
+        href = ((1, 0, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0, phi=0 + ROT))
+        self.check("h", href, U)
+
+    def test_with_z_mismount_k(self):
+        U = z_rotation(ROT)
+        kref = ((0, 1, 0),
+                Pos(alpha=0, delta=60, gamma=0, omega=30 + 90, chi=0,
+                    phi=0 + ROT))
+        self.check("k", kref, U),
+
+    def test_with_z_mismount_l(self):
+        U = z_rotation(ROT)
+        lref = ((0, 0, 1),  # phi degenerate
+                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90, phi=67))
+        self.check("l", lref, I)  # TODO: can't pass - word instructions
+
+    #Probably lost cause, conclusion is be careful and return the angle and
+    #direction of resulting u matrix
+#    def skip_test_with_zy_mismount(self):
+#        U = z_rotation(ROT) * y_rotation(ROT)
+#        href = ((1, 0, 0),
+#                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=0 - ROT,
+#                    phi=0 + ROT))
+#        kref = ((0, 1, 0),
+#                Pos(alpha=0, delta=60, gamma=0, omega=30 + 90, chi=90 - ROT,
+#                    phi=0 + ROT))
+#        lref = ((0, 0, 1),
+#                Pos(alpha=0, delta=60, gamma=0, omega=30, chi=90 - ROT,
+#                    phi=ROT))  # chi degenerate
+#        pairs = (("h", href, U),
+#                 ("k", kref, U),
+#                 ("l", lref, U))
+#        for testname, ref, u in pairs:
+#            yield self.check, testname, ref, u
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation_you.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation_you.py
new file mode 100644
index 0000000..819add4
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_calculation_you.py	
@@ -0,0 +1,83 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from math import pi
+from mock import Mock
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from diffcalc.hkl.you.geometry import SixCircle
+from diffcalc.hkl.you.geometry import YouPosition
+from diffcalc.hkl.you.calc import YouUbCalcStrategy
+from test.tools import matrixeq_
+from diffcalc.ub.calc import UBCalculation
+from diffcalc.ub.persistence import UbCalculationNonPersister
+
+#newub 'cubic'                   <-->  reffile('cubic)
+#setlat 'cubic' 1 1 1 90 90 90   <-->  latt([1,1,1,90,90,90])
+#pos wl 1                        <-->  BLi.setWavelength(1)
+#                                <-->  c2th([0,0,1]) --> 60
+#pos sixc [0 60 0 30 1 1]        <-->  pos euler [1 1 30 0 60 0]
+#addref 1 0 0                    <-->  saveref('100',[1, 0, 0])
+#pos chi 91                      <-->
+#addref 0 0 1                    <-->  saveref('100',[1, 0, 0]) ; showref()
+#                                      ubm('100','001')
+#                                      ubm() ->
+#array('d', [0.9996954135095477, -0.01745240643728364, -0.017449748351250637,
+#0.01744974835125045, 0.9998476951563913, -0.0003045864904520898,
+#0.017452406437283505, -1.1135499981271473e-16, 0.9998476951563912])
+
+
+def posFromI16sEuler(phi, chi, eta, mu, delta, gamma):
+    return YouPosition(mu, delta, gamma, eta, chi, phi, unit='DEG')
+
+UB1 = matrix(
+    ((0.9996954135095477, -0.01745240643728364, -0.017449748351250637),
+     (0.01744974835125045, 0.9998476951563913, -0.0003045864904520898),
+     (0.017452406437283505, -1.1135499981271473e-16, 0.9998476951563912))
+    ) * (2 * pi)
+
+EN1 = 12.39842
+REF1a = posFromI16sEuler(1, 1, 30, 0, 60, 0)
+REF1b = posFromI16sEuler(1, 91, 30, 0, 60, 0)
+
+
+class TestUBCalculationWithYouStrategy():
+    """Testing the math only here.
+    """
+
+    def setup_method(self):
+        geometry = SixCircle()  # pass through
+        hardware = Mock()
+        names = 'm', 'd', 'n', 'e', 'c', 'p'
+        hardware.get_axes_names.return_value = names
+        self.ubcalc = UBCalculation(hardware,
+                                    geometry,
+                                    UbCalculationNonPersister(),
+                                    YouUbCalcStrategy())
+
+    def testAgainstI16Results(self):
+        self.ubcalc.start_new('cubcalc')
+        self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
+        self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
+        self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
+        self.ubcalc.calculate_UB()
+        matrixeq_(self.ubcalc.UB, UB1)
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_crystal.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_crystal.py
new file mode 100644
index 0000000..4a4ee20
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_crystal.py	
@@ -0,0 +1,62 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import unittest
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+from test.tools import assert_dict_almost_equal, mneq_
+from diffcalc.ub.crystal import CrystalUnderTest
+from test.diffcalc import scenarios
+
+
+class TestCrystalUnderTest(object):
+
+    def setup_method(self):
+        self.tclatt = []
+        self.tcbmat = []
+
+        # From the dif_init.mat next to dif_dos.exe on Vlieg's cd
+        #self.tclatt.append([4.0004, 4.0004, 2.270000, 90, 90, 90])
+        #self.tcbmat.append([[1.570639, 0, 0] ,[0.0, 1.570639, 0] ,
+        #                    [0.0, 0.0, 2.767923]])
+
+        # From b16 on 27June2008 (From Chris Nicklin)
+        # self.tclatt.append([3.8401, 3.8401, 5.43072, 90, 90, 90])
+        # self.tcbmat.append([[1.636204, 0, 0],[0, 1.636204, 0],
+        #                     [0, 0, 1.156971]])
+
+    def testGetBMatrix(self):
+        # Check the calculated B Matrix
+        for sess in scenarios.sessions():
+            if sess.bmatrix is None:
+                continue
+            cut = CrystalUnderTest('tc', *sess.lattice)
+            desired = matrix(sess.bmatrix)
+            print desired.tolist()
+            answer = cut.B
+            print answer.tolist()
+            note = "Incorrect B matrix calculation for scenario " + sess.name
+            mneq_(answer, desired, 4, note=note)
+
+    def test__str__(self):
+        cut = CrystalUnderTest("HCl", 1, 2, 3, 4, 5, 6)
+        print cut.__str__()
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_persistence.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_persistence.py
new file mode 100644
index 0000000..b1fc10e
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_persistence.py	
@@ -0,0 +1,100 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+import os
+import shutil
+import unittest
+import tempfile
+import time
+from nose.tools import eq_  # @UnresolvedImport
+
+try:
+    from gda.configuration.properties import LocalProperties
+except ImportError:
+    print "Could not import LocalProperties to configure database locations."
+
+from diffcalc.ub.persistence import UbCalculationNonPersister, UBCalculationJSONPersister
+
+
+def prepareEmptyGdaVarFolder():
+    vartest_dir = os.path.join(os.getcwd(), 'var_test')
+    LocalProperties.set('gda.var', vartest_dir)
+    if os.path.exists(vartest_dir):
+        print "Removing existing gda.var: ", vartest_dir
+        shutil.rmtree(vartest_dir)
+    print "Creating gda.var: ", vartest_dir
+    os.mkdir(vartest_dir)
+
+
+class TestUBCalculationNonPersister(object):
+
+    def setup_method(self):
+        self.persister = UbCalculationNonPersister()
+
+    def testSaveAndLoad(self):
+        self.persister.save('string1', 'ub1')
+
+
+class TestUBCalculationJSONPersister(object):
+
+    def setup_method(self):
+        self.tmpdir = tempfile.mkdtemp()
+        print self.tmpdir
+        self.persister = UBCalculationJSONPersister(self.tmpdir)
+        f = open(os.path.join(self.tmpdir, 'unexpected_file'), 'w')
+        f.close()
+        
+    def test_list_with_empty_dir(self):
+        eq_(self.persister.list(), [])
+        
+    def test_save_load(self):
+        d = {'a' : 1, 'b': 2}
+        self.persister.save(d, 'first')
+        eq_(self.persister.load('first'), d)
+
+    def test_save_overwites(self):
+        d1 = {'a' : 1, 'b': 2}
+        self.persister.save(d1, 'first')
+        eq_(self.persister.load('first'), d1)
+
+        d2 = {'a' : 3, 'b': 4, 'c' : 5}
+        self.persister.save(d2, 'first')
+        eq_(self.persister.load('first'), d2)
+
+    def test_list(self):
+        d = {'a' : 1, 'b': 2}
+        self.persister.save(d, 'first')
+        eq_(self.persister.list(), ['first'])
+        
+    def test_multiple_list(self):
+        d = {'a' : 1, 'b': 2}
+        self.persister.save(d, 'first_written')
+        time.sleep(.5)
+        self.persister.save(d, 'second_written')
+        time.sleep(.5)
+        self.persister.save(d, 'third_written')
+        eq_(self.persister.list(), ['third_written', 'second_written', 'first_written'])
+        
+    def test_remove_list(self):
+        d = {'a' : 1, 'b': 2}
+        self.persister.save(d, 'first')
+        self.persister.remove('first')
+        eq_(self.persister.list(), [])
+        
+    
+
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_reference.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_reference.py
new file mode 100644
index 0000000..60b04e8
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_reference.py	
@@ -0,0 +1,61 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from mock import Mock
+from diffcalc.ub.reference import YouReference
+from test.tools import assert_array_almost_equal, assert_2darray_almost_equal
+
+try:
+    from numpy import matrix, hstack
+    from numpy.linalg import norm
+except ImportError:
+    from numjy import matrix, hstack
+    from numjy.linalg import norm
+
+
+class TestYouReference():
+
+    def setup_method(self):
+        self.get_UB = Mock()
+        self.reference = YouReference(self.get_UB)
+        self.get_UB.return_value = matrix('1 0 0; 0 1 0; 0 0 1')
+
+    def test_default_n_phi(self):
+        assert_2darray_almost_equal(self.reference.n_phi.tolist(), matrix('0; 0; 1').tolist())
+        
+    def test__str__with_phi_configured(self):
+        print self.reference
+        
+    def test__str__with_hkl_configured(self):
+        self.reference.n_hkl_configured = matrix('0; 1; 1')
+        print self.reference
+        
+    def test_n_phi_from_hkl_with_unity_matrix_001(self):
+        self.get_UB.return_value = matrix('1 0 0; 0 1 0; 0 0 1')
+        self.reference.n_hkl_configured = matrix('0; 0; 1')
+        assert_2darray_almost_equal(self.reference.n_phi.tolist(), matrix('0; 0; 1').tolist())
+
+    def test_n_phi_from_hkl_with_unity_matrix_010(self):
+        self.get_UB.return_value = matrix('1 0 0; 0 1 0; 0 0 1')
+        self.reference.n_hkl_configured = matrix('0; 1; 0')
+        assert_2darray_almost_equal(self.reference.n_phi.tolist(), matrix('0; 1; 0').tolist())
+        
+        
+        
+
+ 
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_reflections.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_reflections.py
new file mode 100644
index 0000000..b879eb0
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_reflections.py	
@@ -0,0 +1,91 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from datetime import datetime
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry
+from diffcalc.ub.reflections import ReflectionList
+from diffcalc.hkl.vlieg.geometry  import VliegPosition as Pos
+import unittest
+
+
+class TestReflectionList(object):
+
+    def setup_method(self):
+        self._geometry = SixCircleGammaOnArmGeometry()
+        self.reflist = ReflectionList(self._geometry,
+                                      ['a', 'd', 'g', 'o', 'c', 'p'])
+        self.time = datetime.now()
+        pos = Pos(0.1, 0.2, 0.3, 0.4, 0.5, 0.6)
+        self.reflist.add_reflection(1, 2, 3, pos, 1000, "ref1", self.time)
+        pos = Pos(0.11, 0.22, 0.33, 0.44, 0.55, 0.66)
+        self.reflist.add_reflection(1.1, 2.2, 3.3, pos, 1100, "ref2", self.time)
+
+    def test_add_reflection(self):
+        assert len(self.reflist) == 2
+
+    def testGetReflection(self):
+        answered = self.reflist.getReflection(1)
+        pos = Pos(0.1, 0.2, 0.3, 0.4, 0.5, 0.6)
+        desired = ([1, 2, 3], pos, 1000, "ref1", self.time)
+        assert answered == desired
+
+    def testRemoveReflection(self):
+        self.reflist.removeReflection(1)
+        answered = self.reflist.getReflection(1)
+        pos = Pos(0.11, 0.22, 0.33, 0.44, 0.55, 0.66)
+        desired = ([1.1, 2.2, 3.3], pos, 1100, "ref2", self.time)
+        assert answered == desired
+
+    def testedit_reflection(self):
+        ps = Pos(0.1, 0.2, 0.3, 0.4, 0.5, 0.6)
+        self.reflist.edit_reflection(1, 10, 20, 30, ps, 1000, "new1", self.time)
+        assert (self.reflist.getReflection(1)
+                == ([10, 20, 30], ps, 1000, "new1", self.time))
+        pos = Pos(0.11, 0.22, 0.33, 0.44, 0.55, 0.66)
+        assert (self.reflist.getReflection(2)
+                == ([1.1, 2.2, 3.3], pos, 1100, "ref2", self.time))
+
+    def testSwapReflection(self):
+        self.reflist.swap_reflections(1, 2)
+        pos = Pos(0.11, 0.22, 0.33, 0.44, 0.55, 0.66)
+        assert (self.reflist.getReflection(1)
+                == ([1.1, 2.2, 3.3], pos, 1100, "ref2", self.time))
+        pos = Pos(0.1, 0.2, 0.3, 0.4, 0.5, 0.6)
+        assert (self.reflist.getReflection(2)
+                 == ([1, 2, 3], pos, 1000, "ref1", self.time))
+
+    def createRefStateDicts(self):
+        ref_0 = {
+            'h': 1,
+            'k': 2,
+            'l': 3,
+            'position': (0.1, 0.2, 0.3, 0.4, 0.5, 0.6),
+            'energy': 1000,
+            'tag': "ref1",
+            'time': repr(self.time)
+        }
+        ref_1 = {
+            'h': 1.1,
+            'k': 2.2,
+            'l': 3.3,
+            'position': (0.11, 0.22, 0.33, 0.44, 0.55, 0.66),
+            'energy': 1100,
+            'tag': "ref2",
+            'time': repr(self.time)
+        }
+        return ref_0, ref_1
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/test/diffcalc/ub/test_ub.py b/script/test/diffcalc (copy)/test/diffcalc/ub/test_ub.py
new file mode 100644
index 0000000..609bf7d
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcalc/ub/test_ub.py	
@@ -0,0 +1,734 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from nose.tools import eq_  # @UnresolvedImport
+import tempfile
+import os.path
+import pytest
+from math import atan, sqrt
+from nose import SkipTest
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+import diffcalc.util  # @UnusedImport
+from diffcalc.hkl.vlieg.geometry import SixCircleGammaOnArmGeometry,\
+    VliegPosition
+from diffcalc.hkl.you.geometry import SixCircle
+from diffcalc.hardware import DummyHardwareAdapter
+from test.tools import assert_iterable_almost_equal, mneq_, arrayeq_
+from diffcalc.ub.persistence import UbCalculationNonPersister,\
+    UBCalculationJSONPersister
+from diffcalc.util import DiffcalcException, MockRawInput, xyz_rotation,\
+    TODEG, TORAD
+from diffcalc.hkl.vlieg.calc import VliegUbCalcStrategy, vliegAnglesToHkl
+from diffcalc.hkl.you.calc import youAnglesToHkl, YouUbCalcStrategy
+from test.diffcalc import scenarios
+from test.diffcalc.scenarios import YouPositionScenario
+
+
+diffcalc.util.DEBUG = True
+
+
+def prepareRawInput(listOfStrings):
+    diffcalc.util.raw_input = MockRawInput(listOfStrings)
+
+prepareRawInput([])
+
+from diffcalc import settings
+
+
+
+class _UBCommandsBase():
+
+    def setup_method(self):
+        names = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
+        self.hardware = DummyHardwareAdapter(names)
+        settings.hardware = self.hardware
+        settings.ubcalc_persister = UbCalculationNonPersister()
+        settings.Pos = None
+        self.t_matrix = matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        self.t_hand = 1
+
+        from diffcalc.ub import ub
+        reload(ub)
+        self.ub = ub
+        #self.ub.ubcalc = ub.ubcalc
+        prepareRawInput([])
+        diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
+
+    def testNewUb(self):
+        self.ub.newub('test1')
+        eq_(self.ub.ubcalc._state.name, 'test1')
+        with pytest.raises(TypeError):
+            self.ub.newub(1)
+
+    def testNewUbInteractively(self):
+        prepareRawInput(['ubcalcname', 'xtal', '1', '2', '3', '91', '92',
+                         '93'])
+        self.ub.newub()
+
+    def testLoadub(self):
+        with pytest.raises(TypeError):
+            self.ub.loadub((1, 2))
+
+    def testSaveubcalcas(self):
+        with pytest.raises(TypeError):
+            self.ub.saveubas(1)
+        with pytest.raises(TypeError):
+            self.ub.saveubas((1, 2))
+        self.ub.saveubas('blarghh')
+
+    def testUb(self):
+        with pytest.raises(TypeError):
+            self.ub.showref((1))
+        self.ub.ub()
+        self.ub.newub('testubcalc')
+        self.ub.ub()
+
+    def testSetlat(self):
+        # "Exception should result if no UBCalculation started")
+        with pytest.raises(DiffcalcException):
+            self.ub.setlat('HCl', 2)
+
+        self.ub.newub('testing_setlat')
+        with pytest.raises(TypeError):
+            self.ub.setlat(1)
+        with pytest.raises(TypeError):
+            self.ub.setlat(1, 2)
+        with pytest.raises(TypeError):
+            self.ub.setlat('HCl')
+        self.ub.setlat('NaCl', 1.1)
+        ubcalc = self.ub.ubcalc
+        eq_(('NaCl', 1.1, 1.1, 1.1, 90, 90, 90), ubcalc._state.crystal.getLattice())
+        self.ub.setlat('NaCl', 1.1, 2.2)
+        eq_(('NaCl', 1.1, 1.1, 2.2, 90, 90, 90), ubcalc._state.crystal.getLattice())
+        self.ub.setlat('NaCl', 1.1, 2.2, 3.3)
+        eq_(('NaCl', 1.1, 2.2, 3.3, 90, 90, 90), ubcalc._state.crystal.getLattice())
+        self.ub.setlat('NaCl', 1.1, 2.2, 3.3, 91)
+        eq_(('NaCl', 1.1, 2.2, 3.3, 90, 90, 91), ubcalc._state.crystal.getLattice())
+        with pytest.raises(TypeError):
+            self.ub.setlat(('NaCl', 1.1, 2.2, 3.3, 91, 92))
+        self.ub.setlat('NaCl', 1.1, 2.2, 3.3, 91, 92, 93)
+        assert_iterable_almost_equal(
+            ('NaCl', 1.1, 2.2, 3.3, 91, 92, 92.99999999999999),
+             ubcalc._state.crystal.getLattice())
+
+    def testSetlatInteractive(self):
+        self.ub.newub('testing_setlatinteractive')
+        prepareRawInput(['xtal', '1', '2', '3', '91', '92', '93'])
+        self.ub.setlat()
+        getLattice = self.ub.ubcalc._state.crystal.getLattice
+        assert_iterable_almost_equal(getLattice(),
+                         ('xtal', 1., 2., 3., 91, 92, 92.999999999999986))
+
+        #Defaults:
+        prepareRawInput(['xtal', '', '', '', '', '', ''])
+        self.ub.setlat()
+        getLattice = self.ub.ubcalc._state.crystal.getLattice
+        eq_(getLattice(), ('xtal', 1., 1., 1., 90, 90, 90))
+
+    def testShowref(self):
+        with pytest.raises(TypeError):
+            self.ub.showref((1))
+        eq_(self.ub.showref(), None)  # No UBCalculation loaded
+        # will be tested, for exceptions at least, implicitly below
+        self.ub.newub('testing_showref')
+        eq_(self.ub.showref(), None)  # No UBCalculation loaded"
+
+    def testAddref(self):
+        with pytest.raises(TypeError):
+            self.ub.addref(1)
+        with pytest.raises(TypeError):
+            self.ub.addref(1, 2)
+        with pytest.raises(TypeError):
+            self.ub.addref(1, 2, 'blarghh')
+        # start new ubcalc
+        self.ub.newub('testing_addref')
+        reflist = self.ub.ubcalc._state.reflist  # for convenience
+
+        pos1 = (1.1, 1.2, 1.3, 1.4, 1.5, 1.6)
+        pos2 = (2.1, 2.2, 2.3, 2.4, 2.5, 2.6)
+        pos3 = (3.1, 3.2, 3.3, 3.4, 3.5, 3.6)
+        pos4 = (4.1, 4.2, 4.3, 4.4, 4.5, 4.6)
+        #
+        self.hardware.energy = 1.10
+        self.hardware.position = pos1
+        self.ub.addref([1.1, 1.2, 1.3])
+        result = reflist.get_reflection_in_external_angles(1)
+        eq_(result[:-1], ([1.1, 1.2, 1.3], pos1, 1.10, None))
+
+        self.hardware.energy = 2.10
+        self.hardware.position = pos2
+        self.ub.addref([2.1, 2.2, 2.3], 'atag')
+        result = reflist.get_reflection_in_external_angles(2)
+        eq_(result[:-1], ([2.1, 2.2, 2.3], pos2, 2.10, 'atag'))
+
+        self.ub.addref([3.1, 3.2, 3.3], pos3, 3.10)
+        result = reflist.get_reflection_in_external_angles(3)
+        eq_(result[:-1], ([3.1, 3.2, 3.3], pos3, 3.10, None))
+
+        self.ub.addref([4.1, 4.2, 4.3], pos4, 4.10, 'tag2')
+        result = reflist.get_reflection_in_external_angles(4)
+        eq_(result[:-1], ([4.1, 4.2, 4.3], pos4, 4.10, 'tag2'))
+
+    def testAddrefInteractively(self):
+        prepareRawInput([])
+        # start new ubcalc
+        self.ub.newub('testing_addref')
+        reflist = self.ub.ubcalc._state.reflist  # for convenience
+
+        pos1 = (1.1, 1.2, 1.3, 1.4, 1.5, 1.6)
+        pos2 = (2.1, 2.2, 2.3, 2.4, 2.5, 2.6)
+        pos3 = (3.1, 3.2, 3.3, 3.4, 3.5, 3.6)
+        pos3s = ['3.1', '3.2', '3.3', '3.4', '3.5', '3.6']
+        pos4 = (4.1, 4.2, 4.3, 4.4, 4.5, 4.6)
+        pos4s = ['4.1', '4.2', '4.3', '4.4', '4.5', '4.6']
+        #
+        self.hardware.energy = 1.10
+        self.hardware.position = pos1
+        prepareRawInput(['1.1', '1.2', '1.3', '', ''])
+        self.ub.addref()
+        result = reflist.get_reflection_in_external_angles(1)
+        eq_(result[:-1], ([1.1, 1.2, 1.3], pos1, 1.10, None))
+
+        self.hardware.energy = 2.10
+        self.hardware.position = pos2
+        prepareRawInput(['2.1', '2.2', '2.3', '', 'atag'])
+        self.ub.addref()
+        result = reflist.get_reflection_in_external_angles(2)
+        eq_(result[:-1], ([2.1, 2.2, 2.3], pos2, 2.10, 'atag'))
+
+        prepareRawInput(['3.1', '3.2', '3.3', 'n'] + pos3s + ['3.10', ''])
+        self.ub.addref()
+        result = reflist.get_reflection_in_external_angles(3)
+        eq_(result[:-1], ([3.1, 3.2, 3.3], pos3, 3.10, None))
+
+        prepareRawInput(['4.1', '4.2', '4.3', 'n'] + pos4s + ['4.10', 'tag2'])
+        self.ub.addref()
+        result = reflist.get_reflection_in_external_angles(4)
+        eq_(result[:-1], ([4.1, 4.2, 4.3], pos4, 4.10, 'tag2'))
+
+    def testEditRefInteractivelyWithCurrentPosition(self):
+        pos1 = (1.1, 1.2, 1.3, 1.4, 1.5, 1.6)
+        pos2 = (2.1, 2.2, 2.3, 2.4, 2.5, 2.6)
+        self.ub.newub('testing_editref')
+        self.ub.addref([1, 2, 3], pos1, 10, 'tag1')
+        self.hardware.energy = 11
+        self.hardware.position = pos2
+        prepareRawInput(['1.1', '', '3.1', 'y', ''])
+        self.ub.editref(1)
+
+        reflist = self.ub.ubcalc._state.reflist  # for convenience
+        result = reflist.get_reflection_in_external_angles(1)
+        eq_(result[:-1], ([1.1, 2, 3.1], pos2, 11, 'tag1'))
+
+    def testEditRefInteractivelyWithEditedPosition(self):
+        pos1 = (1.1, 1.2, 1.3, 1.4, 1.5, 1.6)
+        pos2 = (2.1, 2.2, 2.3, 2.4, 2.5, 2.6)
+        pos2s = ['2.1', '2.2', '2.3', '2.4', '2.5', '2.6']
+        self.ub.newub('testing_editref')
+        self.ub.addref([1, 2, 3], pos1, 10, 'tag1')
+        prepareRawInput(['1.1', '', '3.1', 'n'] + pos2s + ['12', 'newtag'])
+        self.ub.editref(1)
+
+        reflist = self.ub.ubcalc._state.reflist
+        result = reflist.get_reflection_in_external_angles(1)
+        eq_(result[:-1], ([1.1, 2, 3.1], pos2, 12, 'newtag'))
+
+    def testSwapref(self):
+        with pytest.raises(TypeError):
+            self.ub.swapref(1)
+        with pytest.raises(TypeError):
+            self.ub.swapref(1, 2, 3)
+        with pytest.raises(TypeError):
+            self.ub.swapref(1, 1.1)
+        self.ub.newub('testing_swapref')
+        pos = (1.1, 1.2, 1.3, 1.4, 1.5, 1.6)
+        self.ub.addref([1, 2, 3], pos, 10, 'tag1')
+        self.ub.addref([1, 2, 3], pos, 10, 'tag2')
+        self.ub.addref([1, 2, 3], pos, 10, 'tag3')
+        self.ub.swapref(1, 3)
+        self.ub.swapref(1, 3)
+        self.ub.swapref(3, 1)  # end flipped
+        reflist = self.ub.ubcalc._state.reflist
+        tag1 = reflist.get_reflection_in_external_angles(1)[3]
+        tag2 = reflist.get_reflection_in_external_angles(2)[3]
+        tag3 = reflist.get_reflection_in_external_angles(3)[3]
+        eq_(tag1, 'tag3')
+        eq_(tag2, 'tag2')
+        eq_(tag3, 'tag1')
+        self.ub.swapref()
+        tag1 = reflist.get_reflection_in_external_angles(1)[3]
+        tag2 = reflist.get_reflection_in_external_angles(2)[3]
+        eq_(tag1, 'tag2')
+        eq_(tag2, 'tag3')
+
+    def testDelref(self):
+        self.ub.newub('testing_swapref')
+        pos = (1.1, 1.2, 1.3, 1.4, 1.5, 1.6)
+        self.ub.addref([1, 2, 3], pos, 10, 'tag1')
+        reflist = self.ub.ubcalc._state.reflist
+        reflist.get_reflection_in_external_angles(1)
+        self.ub.delref(1)
+        with pytest.raises(IndexError):
+            reflist.get_reflection_in_external_angles(1)
+
+    def testShoworient(self):
+        with pytest.raises(TypeError):
+            self.ub.showorient((1))
+        eq_(self.ub.showorient(), None)  # No UBCalculation loaded
+        # will be tested, for exceptions at least, implicitly below
+        self.ub.newub('testing_showorient')
+        eq_(self.ub.showorient(), None)  # No UBCalculation loaded"
+
+    def testAddorient(self):
+        with pytest.raises(TypeError):
+            self.ub.addorient(1)
+        with pytest.raises(TypeError):
+            self.ub.addorient(1, 2)
+        with pytest.raises(TypeError):
+            self.ub.addorient(1, 2, 'blarghh')
+        # start new ubcalc
+        self.ub.newub('testing_addorient')
+        orientlist = self.ub.ubcalc._state.orientlist  # for convenience
+
+        hkl1 = [1.1, 1.2, 1.3]
+        hkl2 = [2.1, 2.2, 2.3]
+        orient1 = [1.4, 1.5, 1.6]
+        orient2 = [2.4, 2.5, 2.6]
+        #
+        self.ub.addorient(hkl1, orient1)
+        result = orientlist.getOrientation(1)
+        trans_orient1 = self.t_matrix.I * matrix([orient1]).T
+        eq_(result[0], hkl1)
+        mneq_(matrix([result[1]]), trans_orient1.T)
+        eq_(result[2], None)
+
+        self.ub.addorient(hkl2, orient2, 'atag')
+        result = orientlist.getOrientation(2)
+        trans_orient2 = self.t_matrix.I * matrix([orient2]).T
+        eq_(result[0], hkl2)
+        mneq_(matrix([result[1]]), trans_orient2.T)
+        eq_(result[2], 'atag')
+
+    def testAddorientInteractively(self):
+        prepareRawInput([])
+        # start new ubcalc
+        self.ub.newub('testing_addorient')
+        orientlist = self.ub.ubcalc._state.orientlist  # for convenience
+
+        hkl1 = [1.1, 1.2, 1.3]
+        hkl2 = [2.1, 2.2, 2.3]
+        orient1 = [1.4, 1.5, 1.6]
+        orient2 = [2.4, 2.5, 2.6]
+        #
+        prepareRawInput(['1.1', '1.2', '1.3', '1.4', '1.5', '1.6', ''])
+        self.ub.addorient()
+        result = orientlist.getOrientation(1)
+        trans_orient1 = self.t_matrix.I * matrix([orient1]).T
+        eq_(result[0], hkl1)
+        mneq_(matrix([result[1]]), trans_orient1.T)
+        eq_(result[2], None)
+
+        prepareRawInput(['2.1', '2.2', '2.3', '2.4', '2.5', '2.6', 'atag'])
+        self.ub.addorient()
+        result = orientlist.getOrientation(2)
+        trans_orient2 = self.t_matrix.I * matrix([orient2]).T
+        eq_(result[0], hkl2)
+        mneq_(matrix([result[1]]), trans_orient2.T)
+        eq_(result[2], 'atag')
+
+    def testEditOrientInteractively(self):
+        hkl1 = [1.1, 1.2, 1.3]
+        hkl2 = [1.1, 1.2, 3.1]
+        orient1 = [1.4, 1.5, 1.6]
+        orient2 = [2.4, 1.5, 2.6]
+        orient2s = ['2.4', '', '2.6']
+        self.ub.newub('testing_editorient')
+        self.ub.addorient(hkl1, orient1, 'tag1')
+        prepareRawInput(['1.1', '', '3.1'] + orient2s + ['newtag',])
+        self.ub.editorient(1)
+
+        orientlist = self.ub.ubcalc._state.orientlist
+        result = orientlist.getOrientation(1)
+        trans_orient2 = self.t_matrix.I * matrix([orient2]).T
+        eq_(result[0], hkl2)
+        mneq_(matrix([result[1]]), trans_orient2.T)
+        eq_(result[2], 'newtag')
+
+    def testSwaporient(self):
+        with pytest.raises(TypeError):
+            self.ub.swaporient(1)
+        with pytest.raises(TypeError):
+            self.ub.swaporient(1, 2, 3)
+        with pytest.raises(TypeError):
+            self.ub.swaporient(1, 1.1)
+        self.ub.newub('testing_swaporient')
+        hkl = [1.1, 1.2, 1.3]
+        orient = [1.4, 1.5, 1.6]
+        self.ub.addorient(hkl, orient, 'tag1')
+        self.ub.addorient(hkl, orient, 'tag2')
+        self.ub.addorient(hkl, orient, 'tag3')
+        self.ub.swaporient(1, 3)
+        self.ub.swaporient(1, 3)
+        self.ub.swaporient(3, 1)  # end flipped
+        orientlist = self.ub.ubcalc._state.orientlist
+        tag1 = orientlist.getOrientation(1)[2]
+        tag2 = orientlist.getOrientation(2)[2]
+        tag3 = orientlist.getOrientation(3)[2]
+        eq_(tag1, 'tag3')
+        eq_(tag2, 'tag2')
+        eq_(tag3, 'tag1')
+        self.ub.swaporient()
+        tag1 = orientlist.getOrientation(1)[2]
+        tag2 = orientlist.getOrientation(2)[2]
+        eq_(tag1, 'tag2')
+        eq_(tag2, 'tag3')
+
+    def testDelorient(self):
+        self.ub.newub('testing_delorient')
+        hkl = [1.1, 1.2, 1.3]
+        pos = [1.4, 1.5, 1.6]
+        self.ub.addorient(hkl, pos, 'tag1')
+        orientlist = self.ub.ubcalc._state.orientlist
+        orientlist.getOrientation(1)
+        self.ub.delorient(1)
+        with pytest.raises(IndexError):
+            orientlist.getOrientation(1)
+
+    def testSetu(self):
+        # just test calling this method
+        #self.ub.setu([[1,2,3],[1,2,3],[1,2,3]])
+        self.ub.newub('testsetu')
+        setu = self.ub.setu
+        with pytest.raises(TypeError):
+            setu(1, 2)
+        with pytest.raises(TypeError):
+            setu(1)
+        with pytest.raises(TypeError):
+            setu('a')
+        with pytest.raises(TypeError):
+            setu([1, 2, 3])
+        with pytest.raises(TypeError):
+            setu([[1, 2, 3], [1, 2, 3], [1, 2]])
+        # diffCalcException expected if no lattice set yet
+        with pytest.raises(DiffcalcException):
+            setu([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
+        self.ub.setlat('NaCl', 1.1)
+        setu([[1, 2, 3], [1, 2, 3], [1, 2, 3]])  # check no exceptions only
+        setu(((1, 2, 3), (1, 2, 3), (1, 2, 3)))  # check no exceptions only
+
+    def testSetuInteractive(self):
+        self.ub.newub('testsetu')
+        self.ub.setlat('NaCl', 1.1)
+
+        prepareRawInput(['1 2 3', '4 5 6', '7 8 9'])
+        self.ub.setu()
+        a = self.ub.ubcalc.U.tolist()
+        eq_([list(a[0]), list(a[1]), list(a[2])],
+            [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+
+        prepareRawInput(['', ' 9 9.9 99', ''])
+        self.ub.setu()
+
+        a = self.ub.ubcalc.U.tolist()
+        eq_([list(a[0]), list(a[1]), list(a[2])],
+            [[1, 0, 0], [9, 9.9, 99], [0, 0, 1]])
+
+    def testSetub(self):
+        # just test calling this method
+        self.ub.newub('testsetub')
+        setub = self.ub.setub
+        with pytest.raises(TypeError):
+            setub(1, 2)
+        with pytest.raises(TypeError):
+            setub(1)
+        with pytest.raises(TypeError):
+            setub('a')
+        with pytest.raises(TypeError):
+            setub([1, 2, 3])
+        with pytest.raises(TypeError):
+            setub([[1, 2, 3], [1, 2, 3], [1, 2]])
+        setub([[1, 2, 3], [1, 2, 3], [1, 2, 3]])  # check no exceptions only
+        setub(((1, 2, 3), (1, 2, 3), (1, 2, 3)))  # check no exceptions only
+
+    def testSetUbInteractive(self):
+        self.ub.newub('testsetu')
+        self.ub.setlat('NaCl', 1.1)
+
+        prepareRawInput(['1 2 3', '4 5 6', '7 8 9'])
+        self.ub.setub()
+        a = self.ub.ubcalc.UB.tolist()
+        eq_([list(a[0]), list(a[1]), list(a[2])],
+            [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+
+        prepareRawInput(['', ' 9 9.9 99', ''])
+        self.ub.setub()
+        a = self.ub.ubcalc.UB.tolist()
+        eq_([list(a[0]), list(a[1]), list(a[2])],
+            [[1, 0, 0], [9, 9.9, 99], [0, 0, 1]])
+
+    def testCalcub(self):
+        with pytest.raises(TypeError):
+            self.ub.calcub(1)  # wrong input
+        # no ubcalc started:
+        with pytest.raises(DiffcalcException):
+            self.ub.calcub()
+        self.ub.newub('testcalcub')
+        # not enough reflections:
+        with pytest.raises(DiffcalcException):
+            self.ub.calcub()
+
+        s = scenarios.sessions(settings.Pos)[0]
+        self.ub.setlat(s.name, *s.lattice)
+        r = s.ref1
+        self.ub.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        r = s.ref2
+        self.ub.addref(
+            [r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
+        self.ub.calcub()
+        mneq_(self.ub.ubcalc.UB, matrix(s.umatrix) * matrix(s.bmatrix),
+              4, note="wrong UB matrix after calculating U")
+
+    def testOrientub(self):
+        with pytest.raises(TypeError):
+            self.ub.orientub(1)  # wrong input
+        # no ubcalc started:
+        with pytest.raises(DiffcalcException):
+            self.ub.orientub()
+        self.ub.newub('testorientub')
+        # not enough orientations:
+        with pytest.raises(DiffcalcException):
+            self.ub.orientub()
+
+        self.ub.newub('testorientub')
+        s = scenarios.sessions(settings.Pos)[1]
+        self.ub.setlat(s.name, *s.lattice)
+        r1 = s.ref1
+        orient1 = self.t_matrix * matrix('1; 0; 0')
+        self.ub.addorient(
+            (r1.h, r1.k, r1.l), orient1.T.tolist()[0], r1.tag)
+        r2 = s.ref2
+        orient2 = self.t_matrix * matrix('0; -1; 0')
+        self.ub.addorient(
+            (r2.h, r2.k, r2.l), orient2.T.tolist()[0], r2.tag)
+        self.ub.orientub()
+        mneq_(self.ub.ubcalc.UB, matrix(s.umatrix) * matrix(s.bmatrix),
+              4, note="wrong UB matrix after calculating U")
+
+    def testRefineubInteractively(self):
+        self.ub.newub('testing_refineubinteractive')
+        self.ub.setlat('xtal', 1, 1, 1, 90, 90, 90)
+        self.ub.setmiscut(0)
+        prepareRawInput(['1', '1', '', 'n', '0', '60', '0', '30', '0', '0', 'y', 'y'])
+        self.ub.refineub()
+        getLattice = self.ub.ubcalc._state.crystal.getLattice
+        eq_(('xtal', sqrt(2.), sqrt(2.), sqrt(2.), 90, 90, 90), getLattice())
+        mneq_(self.ub.ubcalc.U, matrix('0.70711   0.70711   0.00000; -0.70711   0.70711   0.00000; 0.00000   0.00000   1.00000'),
+              4, note="wrong U matrix after refinement")
+
+    def testRefineubInteractivelyWithPosition(self):
+        self.ub.newub('testing_refineubinteractivepos')
+        self.ub.setlat('xtal', 1, 1, 1, 90, 90, 90)
+        self.ub.setmiscut(0)
+        self.hardware.position = [0, 60, 0, 30, 0, 0]
+        prepareRawInput(['1', '1', '', 'y', 'y', 'y'])
+        self.ub.refineub()
+        getLattice = self.ub.ubcalc._state.crystal.getLattice
+        eq_(('xtal', sqrt(2.), sqrt(2.), sqrt(2.), 90, 90, 90), getLattice())
+        mneq_(self.ub.ubcalc.U, matrix('0.70711   0.70711   0.00000; -0.70711   0.70711   0.00000; 0.00000   0.00000   1.00000'),
+              4, note="wrong U matrix after refinement")
+
+    def testRefineubInteractivelyWithHKL(self):
+        self.ub.newub('testing_refineubinteractivehkl')
+        self.ub.setlat('xtal', 1, 1, 1, 90, 90, 90)
+        self.ub.setmiscut(0)
+        self.hardware.position = [0, 60, 0, 30, 0, 0]
+        prepareRawInput(['y', 'y', 'y'])
+        self.ub.refineub([1, 1, 0])
+        getLattice = self.ub.ubcalc._state.crystal.getLattice
+        eq_(('xtal', sqrt(2.), sqrt(2.), sqrt(2.), 90, 90, 90), getLattice())
+        mneq_(self.ub.ubcalc.U, matrix('0.70711   0.70711   0.00000; -0.70711   0.70711   0.00000; 0.00000   0.00000   1.00000'),
+              4, note="wrong U matrix after refinement")
+
+    def testRefineub(self):
+        self.ub.newub('testing_refineub')
+        self.ub.setlat('xtal', 1, 1, 1, 90, 90, 90)
+        self.ub.setmiscut(0)
+        prepareRawInput(['y', 'y'])
+        self.ub.refineub([1, 1, 0], [0, 60, 0, 30, 0, 0])
+        getLattice = self.ub.ubcalc._state.crystal.getLattice
+        eq_(('xtal', sqrt(2.), sqrt(2.), sqrt(2.), 90, 90, 90), getLattice())
+        mneq_(self.ub.ubcalc.U, matrix('0.70711   0.70711   0.00000; -0.70711   0.70711   0.00000; 0.00000   0.00000   1.00000'),
+              4, note="wrong U matrix after refinement")
+
+    def testC2th(self):
+        self.ub.newub('testc2th')
+        self.ub.setlat('cube', 1, 1, 1, 90, 90, 90)
+        assert self.ub.c2th((0, 0, 1)) == pytest.approx(60)
+
+    def testHKLangle(self):
+        self.ub.newub('testhklangle')
+        self.ub.setlat('cube', 1, 1, 1, 90, 90, 90)
+        assert self.ub.hklangle((0, 0, 1), (0, 0, 2)) == pytest.approx(0)
+        assert self.ub.hklangle((0, 1, 0), (0, 0, 2)) == pytest.approx(90)
+        assert self.ub.hklangle((1, 0, 0), (0, 0, 2)) == pytest.approx(90)
+        assert self.ub.hklangle((1, 1, 0), (0, 0, 2)) == pytest.approx(90)
+        assert self.ub.hklangle((0, 1, 1), (0, 0, 2)) == pytest.approx(45)
+        assert self.ub.hklangle((1, 0, 1), (0, 0, 2)) == pytest.approx(45)
+        assert self.ub.hklangle((1, 1, 1), (0, 0, 2)) == pytest.approx(atan(sqrt(2))*TODEG)
+
+    def testSigtau(self):
+        # sigtau [sig tau]
+        with pytest.raises(TypeError):
+            self.ub.sigtau(1)
+        with pytest.raises(ValueError):
+            self.ub.sigtau(1, 'a')
+        self.ub.sigtau(1, 2)
+        self.ub.sigtau(1, 2.0)
+        eq_(self.ub.ubcalc.sigma, 1)
+        eq_(self.ub.ubcalc.tau, 2.0)
+
+    def testSigtauInteractive(self):
+        prepareRawInput(['1', '2.'])
+        self.ub.sigtau()
+        eq_(self.ub.ubcalc.sigma, 1)
+        eq_(self.ub.ubcalc.tau, 2.0)
+        #Defaults:
+        prepareRawInput(['', ''])
+        self.hardware.position = [None, None, None, None, 3, 4.]
+        self.ub.sigtau()
+        eq_(self.ub.ubcalc.sigma, -3.)
+        eq_(self.ub.ubcalc.tau, -4.)
+
+    def testSetWithString(self):
+        with pytest.raises(TypeError):
+            self.ub.setlat('alpha', 'a')
+        with pytest.raises(TypeError):
+            self.ub.setlat('alpha', 1, 'a')   
+
+    def test_setnphihkl_at_various_phases(self):
+        self.ub.setnphi([1, 0, 1])
+        self.ub.setnhkl([1, 0, 1])
+        self.ub.newub('test')
+        self.ub.setnphi([1, 0, 1])
+        self.ub.setnhkl([1, 0, 1]) 
+        self.ub.setlat('cube', 1, 1, 1, 90, 90, 90)
+        self.ub.setnphi([1, 0, 1])
+        self.ub.setnhkl([1, 0, 1])
+        self.ub.setu([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        self.ub.setnphi([1, 0, 1])
+        self.ub.setnhkl([1, 0, 1])
+
+    def testMiscut(self):
+        self.ub.newub('testsetmiscut')
+        self.ub.setlat('cube', 1, 1, 1, 90, 90, 90)
+        beam_axis = (self.t_matrix * matrix('0; 1; 0')).T.tolist()[0]
+        beam_maxis = (self.t_matrix * matrix('0; -1; 0')).T.tolist()[0]
+        self.ub.setmiscut(self.t_hand * 30, beam_axis)
+        mneq_(self.ub.ubcalc._state.reference.n_hkl, matrix('-0.5000000; 0.00000; 0.8660254'))
+        self.ub.addmiscut(self.t_hand * 15, beam_axis)
+        mneq_(self.ub.ubcalc._state.reference.n_hkl, matrix('-0.7071068; 0.00000; 0.7071068'))
+        self.ub.addmiscut(self.t_hand * 45, beam_maxis)
+        mneq_(self.ub.ubcalc._state.reference.n_hkl, matrix('0.0; 0.0; 1.0'))
+
+
+class TestUbCommandsVlieg(_UBCommandsBase):
+    
+    def setup_method(self):
+        _UBCommandsBase.setup_method(self)
+        settings.geometry = SixCircleGammaOnArmGeometry()
+        settings.ubcalc_strategy = VliegUbCalcStrategy()
+        settings.angles_to_hkl_function = vliegAnglesToHkl
+        settings.Pos = VliegPosition
+
+
+class TestUBCommandsYou(_UBCommandsBase):
+
+    def setup_method(self):
+        _UBCommandsBase.setup_method(self)
+        settings.geometry = SixCircle()
+        settings.ubcalc_strategy = YouUbCalcStrategy()
+        settings.angles_to_hkl_function = youAnglesToHkl
+        settings.Pos = YouPositionScenario
+
+
+class TestUBCommandsCustomGeom(TestUBCommandsYou):
+
+    def setup_method(self):
+        TestUBCommandsYou.setup_method(self)
+        inv = matrix([[0, 0, 1], [0, 1, 0], [1, 0, 0]])
+        self.xrot = xyz_rotation([1, 0 ,0], 30. * TORAD)
+        self.t_matrix = inv * self.xrot
+        self.t_hand = -1
+        settings.geometry = SixCircle(beamline_axes_transform=self.t_matrix.I)
+
+    def testSetu(self):
+        self.ub.newub('testsetu_custom')
+        self.ub.setlat('NaCl', 1.1)
+        zrot = xyz_rotation([0, 0 , 1], self.t_hand * 30. * TORAD)
+        self.ub.setu(zrot.tolist())
+
+        mneq_(self.ub.ubcalc.U, self.xrot)
+
+    def testSetuInteractive(self):
+        # Interactive functionality already tested
+        raise SkipTest()
+
+    def testSetub(self):
+        self.ub.newub('testsetub_custom')
+        self.ub.setlat('NaCl', 1.1)
+        zrot = xyz_rotation([0, 0 , 1], self.t_hand * 30. * TORAD)
+        self.ub.setu(zrot.tolist())
+
+        mneq_(self.ub.ubcalc.UB, self.xrot * self.ub.ubcalc._state.crystal.B)
+
+    def testSetUbInteractive(self):
+        # Interactive functionality already tested
+        raise SkipTest()
+
+class TestUbCommandsJsonPersistence(TestUBCommandsYou):
+
+    def setup_method(self):
+        TestUBCommandsYou.setup_method(self)
+        settings.ubcalc_persister = self._createPersister()
+
+    def _createPersister(self):
+        self.tmpdir = tempfile.mkdtemp()
+        print self.tmpdir
+        self.persister = UBCalculationJSONPersister(self.tmpdir)
+        f = open(os.path.join(self.tmpdir, 'unexpected_file'), 'w')
+        f.close()
+        return self.persister
+
+    def testNewUb(self):
+        self.ub.newub('test1')
+        self.ub.loadub('test1')
+        self.ub.ub()
+        
+    def test_n_phi_persistance(self):
+        self.ub.newub('test1')
+        self.ub.setnphi([0, 1, 0])
+        arrayeq_(self.ub.ubcalc.n_phi.T.tolist()[0], [0, 1, 0])
+        self.ub.loadub('test1')
+        arrayeq_(self.ub.ubcalc.n_phi.T.tolist()[0], [0, 1, 0])
+
diff --git a/script/test/diffcalc (copy)/test/diffcmd/__init__.py b/script/test/diffcalc (copy)/test/diffcmd/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/diffcmd/test_ipython.py b/script/test/diffcalc (copy)/test/diffcmd/test_ipython.py
new file mode 100644
index 0000000..0b31076
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/diffcmd/test_ipython.py	
@@ -0,0 +1,172 @@
+from nose.tools import assert_sequence_equal  # @UnresolvedImport
+from nose.tools import eq_
+from nose import SkipTest
+
+try:
+    import IPython.core.magic  # @UnusedImport
+    from diffcmd.ipython import parse
+    IPYTHON = True
+except ImportError:
+    IPYTHON = False
+
+class CallableNamedObject(object):
+    
+    def __init__(self, name, val):
+        self._name = name
+        self._val = val
+        
+    def method(self):
+        return self._val
+        
+    def __repr__(self):
+        return self._name
+    
+    def __call__(self):
+        return self._val
+    
+
+o1 = CallableNamedObject('o1', 1)
+o2 = CallableNamedObject('o2', 2)
+o3 = CallableNamedObject('o3', 3)
+c = 4
+d = {
+     'o1' : o1,
+     'o2' : o2,
+     'o3' : o3,
+     'c' : 4
+     }
+       
+         
+def check(s, *expected):
+    assert_sequence_equal(parse(s, d), expected)    
+
+
+def assert_raises_syntax_error_with_message(msg, func, *args, **kwargs):
+    try:
+        func(*args, **kwargs)
+        raise AssertionError()
+    except SyntaxError as e:
+        eq_(e.message, msg)
+
+
+
+def setup_module():
+    if not IPYTHON:
+        raise SkipTest('ipython not available')
+    
+    
+def test_parse_spaces():
+    check('')
+    check(' ')
+    check('  ')
+
+def test_parse_commas():
+    assert_raises_syntax_error_with_message(
+        'unexpected comma', parse, '1 2, 3', d)
+    
+def test_parse_numbers():
+    check('1', 1)
+    check('10', 10)
+    check('10 2 3', 10, 2, 3)
+    
+def test_parse_negative_numbers():
+    check('-1', -1)
+    check('-10', -10)
+    check('-10 2 -3', -10, 2, -3)
+
+def test_parse_negative_number_with_space_between_sign_and_digit():
+    msg = 'could not evaluate: "-"'
+    assert_raises_syntax_error_with_message(msg, parse, '- 1', d)
+    assert_raises_syntax_error_with_message(msg, parse, '1 - 1', d)
+
+def test_parse_strings():
+    check("'s1'", 's1')
+    check("'s1' 's2'", 's1', 's2')
+    check('"s1"', 's1')
+    check('"s1" "s2"', 's1', 's2')
+
+def test_parse_strings_containing_spaces():
+    check("'ab cd'", 'ab cd')
+    check("' ab cd '", ' ab cd ')
+    
+def test_parse_strings_containing_commas():
+    check("'ab,cd'", 'ab,cd')
+    check("', ab, cd, '", ', ab, cd, ')
+
+def test_parse_strings_containing_hashes():
+    check("'ab #cd'", 'ab #cd')
+    check("' ab cd# '", ' ab cd# ')
+
+def test_parse_strings_containing_strings():
+    check(''' 1 'ab cd' 2''', 1, 'ab cd', 2)
+    check(''' 1 '"ab" cd' 2''', 1, '"ab" cd', 2)
+
+def test_parse_strings_containing_square_brackets():
+    check("'ab[cd'", 'ab[cd')
+    check("'[ ab cd ]'", '[ ab cd ]')
+    
+def test_parse_objects_and_numbers():
+    check('o1', o1)
+    check('c', 4)
+    check('o1 o2', o1, o2)
+    check('1 o1 o2 2 c', 1, o1, o2, 2, 4)
+
+def test_parse_numbers_with_math():
+    check('1+1', 2)
+    check('-1 1-1 1 1+1', -1, 0, 1, 2)
+
+def test_parse_callables_and_methods():
+    check('o1()', 1)
+    check('o1.method()', 1)
+    
+def test_parse_objects_numbers_and_strings():
+    check(" o1 's2'", o1, 's2')
+    check("1 's1' 's2' -2 o2", 1, 's1', 's2', -2, o2)
+    
+def test_parse_objects_and_numbers_and_extra_spaces():
+    check('  o1   ', o1)
+    check(' o1  o2 ', o1, o2)
+    check('1 o1  o2   -2   ', 1, o1, o2, -2)
+
+def test_parse_lists():
+    check('[]', [])
+    check('[1]', [1])
+    check('[-1 2 3]', [-1, 2, 3])
+    check('[1 2 -3][4]', [1, 2, -3], [4])
+    check('[1 2 3][4 -5]', [1, 2, 3], [4, -5])
+    
+def test_parse_nested_lists():
+    check('[[]]', [[]])
+    check('[[1]]', [[1]])
+    check('[[1 2 3]]', [[1, 2, 3]])
+    check('[[1 2 3] [4 5 6]]', [[1, 2, 3], [4, 5, 6]])
+    check('[[1 2 3][4 5 6]]', [[1, 2, 3], [4, 5, 6]])
+    check('[[1 2 3][4 5 [6 7]]]', [[1, 2, 3], [4, 5, [6, 7]]])
+
+def test_parse_lists_and_others():
+    check('[[]]', [[]])
+    check('[[o1]]', [[o1]])
+    check('[[o1 o2() -3]]', [[o1, 2, -3]])
+    
+def test_parse_unexpected_list_closure():
+    msg = 'could not evaluate: "1, 2], 3"'
+    assert_raises_syntax_error_with_message(msg, parse, '1 2] 3', d)
+    assert_raises_syntax_error_with_message(msg, parse, '1 2 ] 3', d)
+    assert_raises_syntax_error_with_message(msg, parse, '1 2 ]3', d)
+    
+def test_parse_with_trailing_comments():
+    check('1# comment', 1)
+    check('1 # comment', 1)
+    check('1# comment # comment2', 1)
+    check('o1# comment', o1)
+    check('o1()# comment', 1)
+    check('-1# comment', -1)
+    check('1-1# comment', 0)
+
+def test_parse_with_only_comments():
+    check('# comment')
+    check(' # comment')
+    check('  # comment')
+    
+    
+    
diff --git a/script/test/diffcalc (copy)/test/ref/b16_dif_270608_printout_for_SixCircleGammaOnArmTestAgainstDif.txt b/script/test/diffcalc (copy)/test/ref/b16_dif_270608_printout_for_SixCircleGammaOnArmTestAgainstDif.txt
new file mode 100644
index 0000000..9187e85
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/ref/b16_dif_270608_printout_for_SixCircleGammaOnArmTestAgainstDif.txt	
@@ -0,0 +1,690 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+
+#!Go to lattice menu to set lattice parameters
+#lattice
+#a1     3.840100
+#a2     3.840100
+#a3     5.430720
+#a4    90.000000
+#a5    90.000000
+#a6    90.000000
+#compute return
+#!Go to fixed parameter menu to set parameters
+#fixed
+#alpha     0
+#gamma     0.000000
+#incoming     0
+#outgoing     0
+#h_crystal     0.000000
+#k_crystal     0.000000
+#l_crystal     1.000000
+#wave     5.067085
+#mirror 1
+#return
+#!Go to circle limits menu
+#limits
+#alpha   -2.1430   27.8570
+#delta   -2.3070  125.0000
+#gamma  -50.0000   50.0000
+#omega -185.0000   30.0000
+#chi    -14.0000   14.0000
+#phi   -400.0000  400.0000
+#return
+#!Go to orientation menu to set parameters
+#orient
+#sigma    -1.350000 # zeroed for some
+#tau  -106.000000 #zeroed for some
+#surfhkl -4.86513e-03 1.67605e-04 8.64299e-01 #zeroed for some
+
+#input
+#orient 1   1.000   0.000   1.0628
+#      5.000    22.790     0.000     1.552    22.400    14.255
+#orient 2   0.000   1.000   1.0628
+#      5.000    22.790     0.000     4.575    24.275   101.320
+
+
+#DIF.ORIENT>li
+#                      0.997161 -0.062217  0.042420
+#                U =   0.062542  0.998022 -0.006371
+#                     -0.041940  0.009006  0.999080
+#
+#sigma =     0.0000
+#tau   =     0.0000
+#Surface normal in hkl frame = (0.000e+00,0.000e+00,1.000e+00)
+#DIF.FIX>li
+#alpha      =     0.0000
+#gamma      =     0.0000
+#beta_in    =     8.0000
+#beta_out   =     1.0000
+#wavevector =     5.0671  <=>  lambda = 1.2400
+#mirror     =    +1
+#h_crystal  =     0.0000
+#k_crystal  =     0.0000
+#l_crystal  =     1.0000
+#DIF.MODE>li
+#Incidence angle equals outgoing angle
+#Alpha and gamma fixed
+
+{1}
+
+#DIF>cal .7 .9 1.3
+#DEBUGFILE = difbug.txt*** SURFMODE = 1
+#<<< entering angcal.do_hkl_to_angles >>>
+# -> h,k,l = 0.700000 0.900000 1.300000
+# -> alpha_fix = 0.000000
+# -> gamma_fix = 0.000000
+# -> difmode = 3
+# -> BETMODE = 3
+#<- beta_in = 0.145358
+#<-delta_comp = 0.477448
+#<- h_phi_norm:
+#        0.464987                0.639188                0.612557
+# - q_alpha_norm:
+#        0.971641                -0.236463               0.000000
+# -> a =
+#        0.464987                0.639188                0.612557
+# -> b =
+#        0.971641                -0.236463               0.000000
+# <- coxi = 0.300656
+# <- xi = 1.265416
+# - r0_matrix:
+#        0.316787                0.797295                0.513776
+#        -0.664730               0.573015                -0.479361
+#        -0.676594               -0.189667               0.711510
+# -> a =
+#        0.971641                -0.236463               0.000000
+# -> b =
+#        1.000000                0.000000                0.000000
+# <- coxi = 0.971641
+# <- xi = 0.238724
+# - t_matrix:
+#        0.971641                -0.236463               0.000000
+#        0.236463                0.971641                0.000000
+#        0.000000                0.000000                1.000000
+# - surf_norm_phi:
+#        0.000000                -0.000000               1.000000
+# - surf_psi:
+#        0.612557                -0.344278               0.711510
+# - v21=-0.236463 - v22=0.971641 - v23=0.000000 - a=-0.334514 - b=0.691332 - c=0.
+#000000
+# psi=0.450660←[0;1;33;44mWARNING, chi outside limits←[0;1;37;44m
+#       h       k       l    alpha    delta    gamma    omega      chi      phi
+#   0.700   0.900   1.300   0.0000  27.3557   0.0000  13.6779  37.7746  53.9654
+#
+#                          beta_in beta_out      rho      eta twotheta
+#                           8.3284   8.3284  36.5258   0.1117  27.3557
+
+
+{2}
+#DIF.FIX>al
+#Rotary table angle (if fixed): 5
+#DIF.FIX>re
+#DIF>calc .7 .9 1.3
+#DEBUGFILE = difbug.txt*** SURFMODE = 1
+#<<< entering angcal.do_hkl_to_angles >>>
+# -> h,k,l = 0.700000 0.900000 1.300000
+# -> alpha_fix = 0.087266
+# -> gamma_fix = 0.000000
+# -> difmode = 3
+# -> BETMODE = 3
+#<- beta_in = 0.145358
+#<-delta_comp = 0.470011
+#<- h_phi_norm:
+#        0.464987                0.639188                0.612557
+# - q_alpha_norm:
+#        0.957647                -0.221243               0.184291
+# -> a =
+#        0.464987                0.639188                0.612557
+# -> b =
+#        0.957647                -0.221243               0.184291
+# <- coxi = 0.416766
+# <- xi = 1.140911
+# - r0_matrix:
+#        0.462060                0.804557                0.373079
+#        -0.625426               0.593875                -0.506117
+#        -0.628763               0.000523                0.777597
+# -> a =
+#        0.957647                -0.221243               0.184291
+# -> b =
+#        1.000000                0.000000                0.000000
+# <- coxi = 0.957647
+# <- xi = 0.292079
+# - t_matrix:
+#        0.957647                -0.221243               0.184291
+#        0.221243                0.974996                0.020828
+#        -0.184291               0.020828                0.982651
+# - surf_norm_phi:
+#        0.000000                -0.000000               1.000000
+# - surf_psi:
+#        0.612557                -0.394726               0.684811
+# - v21=-0.236463 - v22=0.969471 - v23=-0.064895 - a=-0.427116 - b=0.638288 - c=0
+#.000000
+# psi=0.589726←[0;1;33;44mWARNING, chi outside limits←[0;1;37;44m
+#       h       k       l    alpha    delta    gamma    omega      chi      phi
+#   0.700   0.900   1.300   5.0000  26.9296   0.0000   8.4916  27.2563  59.5855
+#
+#                          beta_in beta_out      rho      eta twotheta
+#                           8.3284   8.3284  26.9332   0.1117  27.3557
+{3}
+
+#DIF>cal .7 .9 1.3
+#DEBUGFILE = difbug.txt*** SURFMODE = 1
+#<<< entering angcal.do_hkl_to_angles >>>
+# -> h,k,l = 0.700000 0.900000 1.300000
+# -> alpha_fix = 0.087266
+# -> gamma_fix = 0.174533
+# -> difmode = 3
+# -> BETMODE = 3
+#<- beta_in = 0.145358
+#<-delta_comp = 0.400814
+#<- h_phi_norm:
+#        0.464987                0.639188                0.612557
+# - q_alpha_norm:
+#        0.812475                -0.189119               0.551469
+# -> a =
+#        0.464987                0.639188                0.612557
+# -> b =
+#        0.812475                -0.189119               0.551469
+# <- coxi = 0.594714
+# <- xi = 0.933886
+# - r0_matrix:
+#        0.732257                0.678116                0.062920
+#        -0.536408               0.631214                -0.560210
+#        -0.419603               0.376467                0.825958
+# -> a =
+#        0.812475                -0.189119               0.551469
+# -> b =
+#        1.000000                0.000000                0.000000
+# <- coxi = 0.812475
+# <- xi = 0.622411
+# - t_matrix:
+#        0.812475                -0.189119               0.551469
+#        0.189119                0.980267                0.057542
+#        -0.551469               0.057542                0.832208
+# - surf_norm_phi:
+#        0.000000                -0.000000               1.000000
+# - surf_psi:
+#        0.612557                -0.489729               0.620435
+# - v21=-0.236463 - v22=0.971522 - v23=-0.015209 - a=-0.485218 - b=0.595318 - c=0
+#.000000
+# psi=0.683855       h       k       l    alpha    delta    gamma    omega      c
+#hi      phi
+#   0.700   0.900   1.300   5.0000  22.9649  10.0000-137.7796  -4.9721 203.0655
+#
+#                          beta_in beta_out      rho      eta twotheta
+#                           8.3284   8.3284   3.6800   0.1117  27.3557
+
+{4}
+#DIF>fi
+#DIF.FIX>li
+#alpha      =     5.0000
+#gamma      =    10.0000
+#beta_in    =     4.0000
+#beta_out   =     1.0000
+#wavevector =     5.0671  <=>  lambda = 1.2400
+#mirror     =    +1
+#h_crystal  =     0.0000
+#k_crystal  =     0.0000
+#l_crystal  =     1.0000
+#DIF.FIX>re
+#DIF>mo
+#DIF.MODE>li
+#Fixed angle of incidence
+#Alpha and gamma fixed
+
+#DIF>calc .7 .9 1.3
+#DEBUGFILE = difbug.txt*** SURFMODE = 1
+#<<< entering angcal.do_hkl_to_angles >>>
+# -> h,k,l = 0.700000 0.900000 1.300000
+# -> alpha_fix = 0.087266
+# -> gamma_fix = 0.174533
+# -> difmode = 3
+# -> BETMODE = 123
+#<- beta_in = 0.069813
+#<-delta_comp = 0.400814
+#<- h_phi_norm:
+#        0.464987                0.639188                0.612557
+# - q_alpha_norm:
+#        0.812475                -0.189119               0.551469
+# -> a =
+#        0.464987                0.639188                0.612557
+# -> b =
+#        0.812475                -0.189119               0.551469
+# <- coxi = 0.594714
+# <- xi = 0.933886
+# - r0_matrix:
+#        0.732257                0.678116                0.062920
+#        -0.536408               0.631214                -0.560210
+#        -0.419603               0.376467                0.825958
+# -> a =
+#        0.812475                -0.189119               0.551469
+# -> b =
+#        1.000000                0.000000                0.000000
+# <- coxi = 0.812475
+# <- xi = 0.622411
+# - t_matrix:
+#        0.812475                -0.189119               0.551469
+#        0.189119                0.980267                0.057542
+#        -0.551469               0.057542                0.832208
+# - surf_norm_phi:
+#        0.000000                -0.000000               1.000000
+# - surf_psi:
+#        0.612557                -0.489729               0.620435
+# - v21=-0.236463 - v22=0.971522 - v23=-0.015209 - a=-0.485218 - b=0.595318 - c=0
+#.075090
+# psi=0.781784       h       k       l    alpha    delta    gamma    omega      c
+#hi      phi
+#   0.700   0.900   1.300   5.0000  22.9649  10.0000 -11.8850   4.7799  80.4416
+#
+#                          beta_in beta_out      rho      eta twotheta
+#                           4.0000  12.7054   4.6772   0.1866  27.3557
+
+{5}
+DIF>or
+DIF.ORIENT>li
+                      0.997161 -0.062217  0.042420
+                U =   0.062542  0.998022 -0.006371
+                     -0.041940  0.009006  0.999080
+
+sigma =    -1.3500
+tau   =  -106.0000
+Surface normal in hkl frame = (0.000e+00,0.000e+00,0.000e+00)
+DIF.ORIENT>fi
+←[0;1;33;44mERROR, command "fi" not recognized←[0;1;37;44m
+DIF.ORIENT>re
+DIF>fi
+DIF.FIX>li
+alpha      =     5.0000
+gamma      =    10.0000
+beta_in    =     4.0000
+beta_out   =     1.0000
+wavevector =     5.0671  <=>  lambda = 1.2400
+mirror     =    +1
+h_crystal  =     0.0000
+k_crystal  =     0.0000
+l_crystal  =     1.0000
+
+Incidence angle equals outgoing angle
+Alpha and gamma fixed
+DIF.MODE>re
+DIF>calc .7 .9 1.3
+DEBUGFILE = difbug.txt*** SURFMODE = 1
+<<< entering angcal.do_hkl_to_angles >>>
+ -> h,k,l = 0.700000 0.900000 1.300000
+ -> alpha_fix = 0.087266
+ -> gamma_fix = 0.174533
+ -> difmode = 3
+ -> BETMODE = 3
+<- beta_in = 0.142580
+<-delta_comp = 0.400814
+<- h_phi_norm:
+        0.464987                0.639188                0.612557
+ - q_alpha_norm:
+        0.812475                -0.189119               0.551469
+ -> a =
+        0.464987                0.639188                0.612557
+ -> b =
+        0.812475                -0.189119               0.551469
+ <- coxi = 0.594714
+ <- xi = 0.933886
+ - r0_matrix:
+        0.732257                0.678116                0.062920
+        -0.536408               0.631214                -0.560210
+        -0.419603               0.376467                0.825958
+ -> a =
+        0.812475                -0.189119               0.551469
+ -> b =
+        1.000000                0.000000                0.000000
+ <- coxi = 0.812475
+ <- xi = 0.622411
+ - t_matrix:
+        0.812475                -0.189119               0.551469
+        0.189119                0.980267                0.057542
+        -0.551469               0.057542                0.832208
+ - surf_norm_phi:
+        0.006494                -0.022647               0.999722
+ - surf_psi:
+        0.600931                -0.509673               0.615724
+ - v21=-0.236463 - v22=0.971522 - v23=-0.015209 - a=-0.504523 - b=0.590437 - c=0
+.000000
+ psi=0.707095       h       k       l    alpha    delta    gamma    omega      c
+hi      phi
+   0.700   0.900   1.300   5.0000  22.9649  10.0000  30.6586   4.5295  35.4036
+
+                          beta_in beta_out      rho      eta twotheta
+                           8.1693   8.1693   2.8586   0.1294  27.3557
+
+{6}
+Fixed angle of incidence
+Alpha and gamma fixed
+DIF.MODE>re
+DIF>calc .7 .9 1.3
+DEBUGFILE = difbug.txt*** SURFMODE = 1
+<<< entering angcal.do_hkl_to_angles >>>
+ -> h,k,l = 0.700000 0.900000 1.300000
+ -> alpha_fix = 0.087266
+ -> gamma_fix = 0.174533
+ -> difmode = 3
+ -> BETMODE = 123
+<- beta_in = 0.104720
+<-delta_comp = 0.400814
+<- h_phi_norm:
+        0.464987                0.639188                0.612557
+ - q_alpha_norm:
+        0.812475                -0.189119               0.551469
+ -> a =
+        0.464987                0.639188                0.612557
+ -> b =
+        0.812475                -0.189119               0.551469
+ <- coxi = 0.594714
+ <- xi = 0.933886
+ - r0_matrix:
+        0.732257                0.678116                0.062920
+        -0.536408               0.631214                -0.560210
+        -0.419603               0.376467                0.825958
+ -> a =
+        0.812475                -0.189119               0.551469
+ -> b =
+        1.000000                0.000000                0.000000
+ <- coxi = 0.812475
+ <- xi = 0.622411
+ - t_matrix:
+        0.812475                -0.189119               0.551469
+        0.189119                0.980267                0.057542
+        -0.551469               0.057542                0.832208
+ - surf_norm_phi:
+        0.006494                -0.022647               0.999722
+ - surf_psi:
+        0.600931                -0.509673               0.615724
+ - v21=-0.236463 - v22=0.971522 - v23=-0.015209 - a=-0.504523 - b=0.590437 - c=0
+.037569
+ psi=0.755489       h       k       l    alpha    delta    gamma    omega      c
+hi      phi
+   0.700   0.900   1.300   5.0000  22.9649  10.0000   2.2388   4.3898  65.4395
+
+                          beta_in beta_out      rho      eta twotheta
+                           6.0000  10.3504   3.3267   0.1664  27.3557
+
+{7}
+DIF.FIX>re
+DIF>calc .7 .9 1.3
+DEBUGFILE = difbug.txt*** SURFMODE = 1
+<<< entering angcal.do_hkl_to_angles >>>
+ -> h,k,l = 0.700000 0.900000 1.300000
+ -> alpha_fix = 0.087266
+ -> gamma_fix = 0.174533
+ -> difmode = 3
+ -> BETMODE = 2
+<- beta_in = 0.163048
+<-delta_comp = 0.400814
+<- h_phi_norm:
+        0.464987                0.639188                0.612557
+ - q_alpha_norm:
+        0.812475                -0.189119               0.551469
+ -> a =
+        0.464987                0.639188                0.612557
+ -> b =
+        0.812475                -0.189119               0.551469
+ <- coxi = 0.594714
+ <- xi = 0.933886
+ - r0_matrix:
+        0.732257                0.678116                0.062920
+        -0.536408               0.631214                -0.560210
+        -0.419603               0.376467                0.825958
+ -> a =
+        0.812475                -0.189119               0.551469
+ -> b =
+        1.000000                0.000000                0.000000
+ <- coxi = 0.812475
+ <- xi = 0.622411
+ - t_matrix:
+        0.812475                -0.189119               0.551469
+        0.189119                0.980267                0.057542
+        -0.551469               0.057542                0.832208
+ - surf_norm_phi:
+        0.006494                -0.022647               0.999722
+ - surf_psi:
+        0.600931                -0.509673               0.615724
+ - v21=-0.236463 - v22=0.971522 - v23=-0.015209 - a=-0.504523 - b=0.590437 - c=-
+0.020228
+ psi=0.681046       h       k       l    alpha    delta    gamma    omega      c
+hi      phi
+   0.700   0.900   1.300   5.0000  22.9649  10.0000  43.4628   5.0387  21.7292
+
+                          beta_in beta_out      rho      eta twotheta
+                           9.3419   7.0000   2.6310   0.1095  27.3557
+                           
+{8}
+
+                           8.1693   8.1693   0.0000   0.1294  27.3557
+DIF>mo
+DIF.MODE>li
+Incidence angle equals outgoing angle
+Out-of-plane angle (gamma) fixed
+Surface normal horizontal
+DIF.MODE>re
+DIF>fi
+DIF.FIX>li
+alpha      =     5.0000
+gamma      =    10.0000
+beta_in    =     8.0000
+beta_out   =     1.0000
+wavevector =     5.0671  <=>  lambda = 1.2400
+mirror     =    +1
+h_crystal  =     0.0000
+k_crystal  =     0.0000
+l_crystal  =     1.0000
+DIF.FIX>re
+DIF>or
+DIF.ORIENT>li
+                      0.997161 -0.062217  0.042420
+                U =   0.062542  0.998022 -0.006371
+                     -0.041940  0.009006  0.999080
+
+sigma =    -1.3500
+tau   =  -106.0000
+Surface normal in hkl frame = (0.000e+00,0.000e+00,0.000e+00)
+                           
+-> h,k,l = 0.700000 0.900000 1.300000
+-> alpha_fix = 0.087266
+-> gamma_fix = 0.174533
+-> difmode = 2
+-> BETMODE = 3
+- beta_in = 0.142580
+-> a =
+       0.006494                -0.022647               0.999722
+-> b =
+       0.000000                -0.142098               0.989853
+<- coxi = 0.992796
+<- xi = 0.120106
+-delta_comp = 0.386317
+- h_phi_norm:
+       0.464987                0.639188                0.612557
+- q_alpha_norm:
+       0.784595                -0.173246               0.595312
+-> a =
+       0.464987                0.639188                0.612557
+-> b =
+       0.784595                -0.173246               0.595312
+<- coxi = 0.618753
+<- xi = 0.903642
+- r0_matrix:
+       0.765049                0.643327                0.028814
+       -0.520794               0.644410                -0.559919
+       -0.378779               0.413359                0.828046
+-> a =
+       0.784595                -0.173246               0.595312
+-> b =
+       1.000000                0.000000                0.000000
+<- coxi = 0.784595
+<- xi = 0.668754
+- t_matrix:
+       0.784595                -0.173246               0.595312
+       0.173246                0.983182                0.057792
+       -0.595312               0.057792                0.801413
+- surf_norm_phi:
+       0.006494                -0.022647               0.999722
+- surf_psi:
+       0.600931                -0.517538               0.609128
+- v21=-0.236463 - v22=0.971207 - v23=-0.029010 - a=-0.520308 - b=0.576575 - c=-
+.000000
+psi=0.734145       h       k       l    alpha    delta    gamma    omega      c
+i      phi
+  0.700   0.900   1.300   6.1937  22.1343  10.0000  46.9523   1.5102  18.8112
+
+                         beta_in beta_out      rho      eta twotheta
+                          8.1693   8.1693   0.0000   0.1294  27.3557
+
+{9}
+DIF>mo
+DIF.MODE>li
+Incidence angle equals outgoing angle
+Rotary table (alpha) fixed
+Surface normal horizontal
+DIF.MODE>re
+DIF>fi
+DIF.FIX>li
+alpha      =     5.0000
+gamma      =    10.0000
+beta_in    =     8.0000
+beta_out   =     1.0000
+wavevector =     5.0671  <=>  lambda = 1.2400
+mirror     =    +1
+h_crystal  =     0.0000
+k_crystal  =     0.0000
+l_crystal  =     1.0000
+
+-> h,k,l = 0.700000 0.900000 1.300000
+-> alpha_fix = 0.087266
+-> gamma_fix = 0.174533
+-> difmode = 123
+-> BETMODE = 3
+- beta_in = 0.142580
+-> a =
+       0.006494                -0.022647               0.999722
+-> b =
+       0.000000                -0.142098               0.989853
+<- coxi = 0.992796
+<- xi = 0.120106
+-delta_comp = 0.387782
+- h_phi_norm:
+       0.464987                0.639188                0.612557
+- q_alpha_norm:
+       0.784595                -0.185610               0.591574
+-> a =
+       0.464987                0.639188                0.612557
+-> b =
+       0.784595                -0.185610               0.591574
+<- coxi = 0.608560
+<- xi = 0.916552
+- r0_matrix:
+       0.758937                0.650653                0.025810
+       -0.524967               0.634822                -0.566931
+       -0.385260               0.416716                0.823361
+-> a =
+       0.784595                -0.185610               0.591574
+-> b =
+       1.000000                0.000000                0.000000
+<- coxi = 0.784595
+<- xi = 0.668754
+- t_matrix:
+       0.784595                -0.185610               0.591574
+       0.185610                0.980695                0.061528
+       -0.591574               0.061528                0.803900
+- surf_norm_phi:
+       0.006494                -0.022647               0.999722
+- surf_psi:
+       0.600931                -0.520396               0.606688
+- v21=-0.236463 - v22=0.971601 - v23=-0.008771 - a=-0.510938 - b=0.584895 - c=0
+000000
+psi=0.718011       h       k       l    alpha    delta    gamma    omega      c
+i      phi
+  0.700   0.900   1.300   5.0000  22.2183  11.1054  65.8276   2.5180  -0.0749
+
+                         beta_in beta_out      rho      eta twotheta
+                          8.1693   8.1693  -0.0000   0.1294  27.3557
+                          
+{10}
+DIF.MODE>Zaxis
+DIF.MODE>li
+Incidence angle equals outgoing angle
+Z-axis mode
+Surface normal horizontal
+DIF.MODE>re
+DIF>fi
+DIF.FIX>li
+alpha      =     5.0000
+gamma      =    10.0000
+beta_in    =     8.0000
+beta_out   =     1.0000
+wavevector =     5.0671  <=>  lambda = 1.2400
+mirror     =    +1
+h_crystal  =     0.0000
+k_crystal  =     0.0000
+l_crystal  =     1.0000
+DIF>calc .7 .9 1.3
+DEBUGFILE = difbug.txt*** SURFMODE = 1
+<<< entering angcal.do_hkl_to_angles >>>
+ -> h,k,l = 0.700000 0.900000 1.300000
+ -> alpha_fix = 0.087266
+ -> gamma_fix = 0.174533
+ -> difmode = 4
+ -> BETMODE = 3<-delta_comp = 0.384244
+       h       k       l    alpha    delta    gamma    omega      chi      phi
+   0.700   0.900   1.300   8.1693  22.0156   8.1693 -40.2188   1.3500 106.0000
+
+                          beta_in beta_out      rho      eta twotheta
+                           8.1693   8.1693  -0.0000   0.1294  27.3557
+
+{11}
+DIF>mo
+DIF.MODE>in
+DIF.MODE>re
+DIF>calc .7 .9 1.3
+DEBUGFILE = difbug.txt*** SURFMODE = 1
+<<< entering angcal.do_hkl_to_angles >>>
+ -> h,k,l = 0.700000 0.900000 1.300000
+ -> alpha_fix = 0.087266
+ -> gamma_fix = 0.000000
+ -> difmode = 4
+ -> BETMODE = 123<-delta_comp = 0.384245
+       h       k       l    alpha    delta    gamma    omega      chi      phi
+   0.700   0.900   1.300   8.0000  22.0156   8.3386 -40.0939   1.3500 106.0000
+
+                          beta_in beta_out      rho      eta twotheta
+                           8.0000   8.3386  -0.0000   0.1322  27.3557
+                           
+{12}
+DIF>mo
+DIF.MODE>out
+DIF.MODE>re
+DIF>calc .7 .9 1.3
+DEBUGFILE = difbug.txt*** SURFMODE = 1
+<<< entering angcal.do_hkl_to_angles >>>
+ -> h,k,l = 0.700000 0.900000 1.300000
+ -> alpha_fix = 0.087266
+ -> gamma_fix = 0.000000
+ -> difmode = 4
+ -> BETMODE = 2<-delta_comp = 0.385708
+       h       k       l    alpha    delta    gamma    omega      chi      phi
+   0.700   0.900   1.300  15.4706  22.0994   1.0000 -45.5521   1.3500 106.0000
+
+                          beta_in beta_out      rho      eta twotheta
+                          15.4706   1.0000  -0.0000   0.0079  27.3557
diff --git a/script/test/diffcalc (copy)/test/ref/i16_reference_results.txt b/script/test/diffcalc (copy)/test/ref/i16_reference_results.txt
new file mode 100644
index 0000000..0b70169
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/ref/i16_reference_results.txt	
@@ -0,0 +1,198 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+
+reffile('cubic') 
+latt([1,1,1,90,90,90])
+pos mywl 1
+c2th([0,0,1])
+#60
+pos euler [1 1 30 0 60 0] # delta + gam not moved
+pos delta 60
+pos gam 0
+saveref('100',[1, 0, 0])
+pos chi 91                      <-->  
+saveref('001',[0, 0, 1]) ; showref()
+ubm('100','001')
+# array('d', [0.9996954135095477, -0.01745240643728364, -0.017449748351250637, 0.01744974835125045, 0.9998476951563913, -0.0003045864904520898, 0.017452406437283505, -1.1135499981271473e-16, 0.9998476951563912])
+
+############################################################################################
+mode euler 1
+
+scan mywl .9 1.1 .02 hkl [1 0 0] euler psi 
+#0.900000	1.0000	0.0000	-0.0000	1.0000	1.0000	26.744	0.0000	53.487	0.0000 90.000
+#0.920000	1.0000	0.0000	-0.0000	1.0000	1.0000	27.387	0.0000	54.774	0.0000 90.000
+#0.940000	1.0000	-0.0000	-0.0000	1.0000	1.0000	28.034	0.0000	56.069	0.0000 90.000
+#0.960000	1.0000	0.0000	-0.0000	1.0000	1.0000	28.685	0.0000	57.371	0.0000 90.000
+#0.980000	1.0000	-0.0000	-0.0000	1.0000	1.0000	29.341	0.0000	58.681	0.0000 90.000
+#1.000000	1.0000	-0.0000	-0.0000	1.0000	1.0000	30.000	0.0000	60.000	0.0000 90.000
+#1.020000	1.0000	-0.0000	-0.0000	1.0000	1.0000	30.664	0.0000	61.328	0.0000 90.000
+#1.040000	1.0000	0.0000	-0.0000	1.0000	1.0000	31.332	0.0000	62.665	0.0000 90.000
+#1.060000	1.0000	-0.0000	-0.0000	1.0000	1.0000	32.005	0.0000	64.011	0.0000 90.000
+#1.080000	1.0000	0.0000	-0.0000	1.0000	1.0000	32.684	0.0000	65.367	0.0000 90.000
+#1.100000	1.0000	0.0000	-0.0000	1.0000	1.0000	33.367	0.0000	66.734	0.0000 90.000
+
+pos mywl 2
+pos hkl [0 1 0]
+psi()
+# 179.00
+
+pos hkl [0 0 1]
+psi()
+# 90.000
+
+pos hkl [1 0 0]
+#Warning::Vector and Azimuthal reference //, azimuthal reference not used
+#Move completed: hkl : h: 1.0000 k: 0.0000 l: -0.0000
+psi()
+90.000
+
+
+pos mywl 2
+mode euler 2
+scan phi -19 21 2 hkl [0 0 1] euler
+#Writing data to file:/home/zrb13439/gda/dev/config-i16/users_test/data/4.dat
+#  value	     h	     k	     l	    phi	   chi	   eta	    mu	 delta	 gamma
+#-19.000	0.0000	0.0000	1.0000	-19.000	90.940	29.658	0.0000	60.000	0.0000
+#-17.000	-0.0000	0.0000	1.0000	-17.000	90.951	29.691	0.0000	60.000	0.0000
+#-15.000	-0.0000	0.0000	1.0000	-15.000	90.961	29.724	0.0000	60.000	0.0000
+#-13.000	0.0000	-0.0000	1.0000	-13.000	90.970	29.758	0.0000	60.000	0.0000
+#-11.000	-0.0000	-0.0000	1.0000	-11.000	90.978	29.792	0.0000	60.000	0.0000
+#-9.0000	-0.0000	-0.0000	1.0000	-9.0000	90.985	29.826	0.0000	60.000	0.0000
+#-7.0000	0.0000	0.0000	1.0000	-7.0000	90.990	29.861	0.0000	60.000	0.0000
+#-5.0000	-0.0000	0.0000	1.0000	-5.0000	90.995	29.895	0.0000	60.000	0.0000
+#-3.0000	-0.0000	-0.0000	1.0000	-3.0000	90.998	29.930	0.0000	60.000	0.0000
+#-1.0000	0.0000	0.0000	1.0000	-1.0000	90.999	29.965	0.0000	60.000	0.0000
+#1.0000	0.0000	0.0000	1.0000	1.0000	91.000	30.000	0.0000	60.000	0.0000
+#3.0000	0.0000	-0.0000	1.0000	3.0000	90.999	30.035	0.0000	60.000	0.0000
+#5.0000	-0.0000	-0.0000	1.0000	5.0000	90.998	30.070	0.0000	60.000	0.0000
+#7.0000	-0.0000	0.0000	1.0000	7.0000	90.995	30.105	0.0000	60.000	0.0000
+#9.0000	-0.0000	0.0000	1.0000	9.0000	90.990	30.139	0.0000	60.000	0.0000
+#11.000	-0.0000	0.0000	1.0000	11.000	90.985	30.174	0.0000	60.000	0.0000
+#13.000	-0.0000	-0.0000	1.0000	13.000	90.978	30.208	0.0000	60.000	0.0000
+#15.000	0.0000	0.0000	1.0000	15.000	90.970	30.242	0.0000	60.000	0.0000
+#17.000	0.0000	-0.0000	1.0000	17.000	90.961	30.276	0.0000	60.000	0.0000
+#19.000	-0.0000	0.0000	1.0000	19.000	90.951	30.309	0.0000	60.000	0.0000
+#21.000	0.0000	-0.0000	1.0000	21.000	90.940	30.342	0.0000	60.000	0.0000
+
+scan phi -19 21 2 hkl [0 0 1] euler psi
+#Writing data to file:/home/zrb13439/gda/dev/config-i16/users_test/data/16.dat
+#  value	     h	     k	     l	    phi	   chi	   eta	    mu	 delta	 gamma	  value
+#-19.000	0.0000	0.0000	1.0000	-19.000	90.940	29.658	0.0000	60.000	0.0000	-70.003
+#-17.000	-0.0000	0.0000	1.0000	-17.000	90.951	29.691	0.0000	60.000	0.0000	-72.003
+#-15.000	-0.0000	0.0000	1.0000	-15.000	90.961	29.724	0.0000	60.000	0.0000	-74.002
+#-13.000	0.0000	-0.0000	1.0000	-13.000	90.970	29.758	0.0000	60.000	0.0000	-76.002
+#-11.000	-0.0000	-0.0000	1.0000	-11.000	90.978	29.792	0.0000	60.000	0.0000	-78.002
+#-9.0000	-0.0000	-0.0000	1.0000	-9.0000	90.985	29.826	0.0000	60.000	0.0000	-80.001
+#-7.0000	0.0000	0.0000	1.0000	-7.0000	90.990	29.861	0.0000	60.000	0.0000	-82.001
+#-5.0000	-0.0000	0.0000	1.0000	-5.0000	90.995	29.895	0.0000	60.000	0.0000	-84.001
+#-3.0000	-0.0000	-0.0000	1.0000	-3.0000	90.998	29.930	0.0000	60.000	0.0000	-86.001
+#-1.0000	0.0000	0.0000	1.0000	-1.0000	90.999	29.965	0.0000	60.000	0.0000	-88.000
+#1.0000	0.0000	0.0000	1.0000	1.0000	91.000	30.000	0.0000	60.000	0.0000	-90.000
+#3.0000	0.0000	-0.0000	1.0000	3.0000	90.999	30.035	0.0000	60.000	0.0000	-92.000
+#5.0000	-0.0000	-0.0000	1.0000	5.0000	90.998	30.070	0.0000	60.000	0.0000	-93.999
+#7.0000	-0.0000	0.0000	1.0000	7.0000	90.995	30.105	0.0000	60.000	0.0000	-95.999
+#9.0000	-0.0000	0.0000	1.0000	9.0000	90.990	30.139	0.0000	60.000	0.0000	-97.999
+#11.000	-0.0000	0.0000	1.0000	11.000	90.985	30.174	0.0000	60.000	0.0000	-99.999
+#13.000	-0.0000	-0.0000	1.0000	13.000	90.978	30.208	0.0000	60.000	0.0000	-102.00
+#15.000	0.0000	0.0000	1.0000	15.000	90.970	30.242	0.0000	60.000	0.0000	-104.00
+#17.000	0.0000	-0.0000	1.0000	17.000	90.961	30.276	0.0000	60.000	0.0000	-106.00
+#19.000	-0.0000	0.0000	1.0000	19.000	90.951	30.309	0.0000	60.000	0.0000	-108.00
+#21.000	0.0000	-0.0000	1.0000	21.000	90.940	30.342	0.0000	60.000	0.0000	-110.00
+
+####################################################################################
+mode euler 3
+scan psic -19 21 2 hkl [0 0 1] euler psi
+#Writing data to file:/home/zrb13439/gda/dev/config-i16/users_test/data/18.dat
+#value	     h	      k	     l	    phi	   chi	   eta	    mu	 delta	 gamma	  value
+#  -19	0.0000	-0.0000	1.0000	-70.003	90.326	29.054	0.0000	60.000	0.0000	-19.000
+#-17.000	0.0000	-0.0000	1.0000	-72.002	90.292	29.044	0.0000	60.000	0.0000	-17.000
+#-15.000	0.0000	-0.0000	1.0000	-74.002	90.259	29.034	0.0000	60.000	0.0000	-15.000
+#-13.000	-0.0000	-0.0000	1.0000	-76.002	90.225	29.026	0.0000	60.000	0.0000	-13.000
+#-11.000	-0.0000	-0.0000	1.0000	-78.002	90.191	29.018	0.0000	60.000	0.0000	-11.000
+#-9.0000	-0.0000	0.0000	1.0000	-80.001	90.156	29.012	0.0000	60.000	0.0000	-9.0000
+#-7.0000	0.0000	0.0000	1.0000	-82.001	90.122	29.007	0.0000	60.000	0.0000	-7.0000
+#-5.0000	0.0000	-0.0000	1.0000	-84.001	90.087	29.004	0.0000	60.000	0.0000	-5.0000
+#-3.0000	-0.0000	0.0000	1.0000	-86.000	90.052	29.001	0.0000	60.000	0.0000	-3.0000
+#-1.0000	-0.0000	0.0000	1.0000	-88.000	90.017	29.000	0.0000	60.000	0.0000	-1.0000
+#1.0000	0.0000	-0.0000	1.0000	-90.000	89.983	29.000	0.0000	60.000	0.0000	1.0000
+#3.0000	-0.0000	-0.0000	1.0000	268.00	89.948	29.001	0.0000	60.000	0.0000	3.0000
+#5.0000	0.0000	-0.0000	1.0000	266.00	89.913	29.004	0.0000	60.000	0.0000	5.0000
+#7.0000	0.0000	0.0000	1.0000	264.00	89.878	29.007	0.0000	60.000	0.0000	7.0000
+#9.0000	-0.0000	-0.0000	1.0000	262.00	89.844	29.012	0.0000	60.000	0.0000	9.0000
+#11.000	0.0000	0.0000	1.0000	260.00	89.809	29.018	0.0000	60.000	0.0000	11.000
+#13.000	-0.0000	0.0000	1.0000	258.00	89.775	29.026	0.0000	60.000	0.0000	13.000
+#15.000	-0.0000	0.0000	1.0000	256.00	89.741	29.034	0.0000	60.000	0.0000	15.000
+#17.000	0.0000	-0.0000	1.0000	254.00	89.708	29.044	0.0000	60.000	0.0000	17.000
+#19.000	0.0000	-0.0000	1.0000	252.00	89.674	29.054	0.0000	60.000	0.0000	19.000
+#21.000	-0.0000	-0.0000	1.0000	250.00	89.642	29.066	0.0000	60.000	0.0000	21.000
+#Scan complete.
+
+##########################################################################################
+# Move gamma and mu and read back hkl positions
+mode euler 1
+pos hkl [1 0 0]
+#Warning::Vector and Azimuthal reference //, azimuthal reference not used
+#Move completed: hkl : h: 1.0000 k: -0.0000 l: -0.0000
+hkl()
+#[0.9999999999999998, -3.8988661640799736e-17, -1.457167719820518e-16]
+euler()
+#[0.9999999999999994, 0.9999999999999912, 30.000000000000007, 0.0, 60.00000000000001, 0.0]
+pos gam 10
+euler()
+#[0.9999999999999994, 0.9999999999999912, 30.000000000000007, 0.0, 60.00000000000001, 10.0]
+hkl()
+#[1.0037980617469482, -0.006578435915997894, 0.08682408883346501]
+
+>>>pos mu 10
+Move completed: mu : 10.000
+>>>hkl()
+[0.996201938253052, 0.006578435915997645, 0.08682408883346503]
+
+
+# arbitrary position:
+>>>euler()
+[1.9, 2.9, 30.9, 0.9, 60.9, 2.9]
+
+>>>hkl()
+[1.0117418909164064, 0.02368622807445844, 0.06627361269425353]
+
+>>>az.getAzimuthalReference().array
+array([D, [array('d', [1.0]), array('d', [0.0]), array('d', [0.0])])
+
+>>>az.calcN_L()
+[0.8494223227931345, -0.5260858416846694, -0.04141744462963532]
+
+>>>az.calcPsi()
+[-109.75394072042344, -109.7539407204235]
+
+>>>az.getAlpha()
+31.741370382777166
+
+>>>az.getBeta()
+29.055463912559212
+
+>>>az.getPhi_az()
+-87.20849481167566
+
+>>>az.calcPsi()
+[-109.75394072042344, -109.7539407204235]
+
+>>>az.getTau()
+0.06945050942570621
+
diff --git a/script/test/diffcalc (copy)/test/ref/output_from_spec.txt b/script/test/diffcalc (copy)/test/ref/output_from_spec.txt
new file mode 100644
index 0000000..482706d
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/ref/output_from_spec.txt	
@@ -0,0 +1,1343 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+
+SIXC.1> com ************ spec_sixc_b16_270608 ************
+
+Mon Jul 28 12:18:45 2008.  ************ spec_sixc_b16_270608 ************.
+
+SIXC.1> LAMBDA=12.39842/10
+
+SIXC.1> setlat 3.8401 3.8401 5.43072 90 90 90
+(UB recalculated from orientation reflections and lattice.)
+
+SIXC.1> 
+SIXC.1> mv mu 5;mv del 22.79;mv gam 0;mv th 1.552;mv chi 22.4;mv phi 14.255;
+
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> or0 1 0 1.0628
+(UB recalculated from orientation reflections and lattice.)
+
+SIXC.1> mv mu 5;mv del 22.79;mv gam 0;mv th 4.575;mv chi 24.275;mv phi 101.32;
+
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> or1 0 1 1.0628
+(UB recalculated from orientation reflections and lattice.)
+
+SIXC.1> g_sect=0
+
+SIXC.1> dofile("sixc_test_scenario_guts.mac")
+
+SIXC.2> Reading file "/mntdirect/_bliss/users/walton/sixc_test_scenario_guts.mac" (level 2).
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-0a : fixed omega = 0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-0a : fixed omega = 0 ***.
+
+SIXC.2> setmode 0
+Now using Omega fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0; OMEGA=0
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352179, 0.000000, 13.676090, 37.774500, 53.965500)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 9.290115, -2.403500, 3.589000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 9.290115, 0.516000, 93.567000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394192, 0.000000, 13.197096, -1.334500, 48.602000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-0b : fixed omega = 15 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-0b : fixed omega = 15 ***.
+
+SIXC.2> setmode 0
+Still using Omega fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0; OMEGA=15
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352179, 0.000000, 28.676090, 39.358000, 34.852000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 24.290115, -2.488500, -11.424500)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 24.290115, 0.534000, 78.566500)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394192, 0.000000, 28.197096, -1.381500, 33.598000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-1a : fixed phi = 0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-1a : fixed phi = 0 ***.
+
+SIXC.2> setmode 1
+Now using Phi fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0;
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352179, 0.000000, 53.407372, 52.798000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 12.875851, -2.408500, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 102.894431, -8.236000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394192, 0.000000, 61.781587, -2.017500, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-1b : fixed phi = 15 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-1b : fixed phi = 15 ***.
+
+SIXC.2> setmode 1
+Still using Phi fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0;
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> mv phi 15
+
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352179, 0.000000, 43.481806, 44.905500, 15.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, -2.110812, -2.452000, 15.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580230, 0.000000, 87.845869, 2.601500, 15.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394192, 0.000000, 46.788887, -1.602000, 15.000000)
+
+SIXC.2> 
+
+SIXC.2> com ****** azimuth fixed ******
+
+Mon Jul 28 12:18:45 2008.  ****** azimuth fixed ******.
+
+SIXC.2> com *** sixc-3a : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 90 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3a : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 90 ***.
+
+SIXC.2> setmode 3
+Now using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352000, 0.000000, 10.067000, 37.863000, 58.533000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -158.591000, 2.458500, 171.459000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -68.591000, 2.458500, 171.459000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394000, 0.000000, -109.684000, 2.458500, 171.459000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-3b : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 37 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3b : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 37 ***.
+
+SIXC.2> setmode 3
+Still using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=37
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352000, 0.000000, -33.187500, 63.623500, 121.365000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -83.698500, 53.553500, 95.365500)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -80.083000, 55.405500, -176.788500)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394000, 0.000000, -78.430500, 55.076000, 139.534000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-3c : azimuth fixed (mu,gamma fixed), sigma=-1.35, tau=-106, azimuth = 90 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3c : azimuth fixed (mu,gamma fixed), sigma=-1.35, tau=-106, azimuth = 90 ***.
+
+SIXC.2> setmode 3
+Still using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352000, 0.000000, 10.067000, 37.863000, 58.533000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -158.591000, 2.458500, 171.459000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -68.591000, 2.458500, 171.459000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394000, 0.000000, -109.684000, 2.458500, 171.459000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-3d : azimuth fixed (mu,gamma fixed),  sigma=-1.35, tau=-106, azimuth = 37 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3d : azimuth fixed (mu,gamma fixed), sigma=-1.35, tau=-106, azimuth = 37 ***.
+
+SIXC.2> setmode 3
+Still using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=37
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 27.352000, 0.000000, -33.187500, 63.623500, 121.365000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -83.698500, 53.553500, 95.365500)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -80.083000, 55.405500, -176.788500)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394000, 0.000000, -78.430500, 55.076000, 139.534000)
+
+SIXC.2> 
+
+SIXC.2> com ****** z axiz, fixed azimuth ******
+
+Mon Jul 28 12:18:45 2008.  ****** z axiz, fixed azimuth ******.
+
+SIXC.2> com *** sixc-12a : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12a : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 12
+Now using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(8.534000, 21.453500, 8.534000, 64.692000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, 12.879000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, 102.857500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394000, 0.000000, 61.799000, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-12b : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12b : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***.
+
+SIXC.2> setmode 12
+Still using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(8.534000, 21.453500, 8.534000, -40.500000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -93.173000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 18.580000, 0.000000, -3.143500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 26.394000, 0.000000, -44.234500, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-12c : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12c : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 12
+Still using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=35
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-28.114500, 21.297500, 50.177000, 104.777500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-53.940500, 31.835500, 53.940500, 19.506500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-53.940500, 31.835500, 53.940500, 109.485000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-52.894000, 44.472500, 52.894000, 70.838500, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-12d : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12d : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***.
+
+SIXC.2> setmode 12
+Still using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=35
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-28.114500, 21.297500, 50.177000, -0.415000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-53.940500, 31.835500, 53.940500, -86.545500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-53.940500, 31.835500, 53.940500, 3.484000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-52.894000, 44.472500, 52.894000, -35.195500, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> com ***** z axis, fixed alpha/Bin beta/Bout*****
+
+Mon Jul 28 12:18:45 2008.  ***** z axis, fixed alpha/Bin beta/Bout*****.
+
+SIXC.2> com *** sixc-13a : z axis, alpha=10 (Bin=10), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-13a : z axis, alpha=10 (Bin=10), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 13
+Now using Z-Axis with Alpha fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> ALPHA=10
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 21.456000, 7.073500, 63.534000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 18.869500, -10.000000, 13.023500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 18.869500, -10.000000, 103.002000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 26.809000, -10.000000, 62.006500, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-13b : z axis, alpha=10  chi, phi = -sigma, -tau, = -1.35, -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-13b : z axis, alpha=10 chi, phi = -sigma, -tau, = -1.35, -106 ***.
+
+SIXC.2> setmode 13
+Still using Z-Axis with Alpha fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> ALPHA=10
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 21.456000, 7.073500, -41.658000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 18.869500, -10.000000, -93.028500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 18.869500, -10.000000, -2.999000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 26.809000, -10.000000, -44.027000, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-14a : z axis, beta=11 (Bout=11), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-14a : z axis, beta=11 (Bout=11), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 14
+Now using Z-Axis with Beta fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> BETA=11
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(6.084000, 21.461000, 11.000000, 66.644500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 18.931000, 11.000000, 13.054500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 18.931000, 11.000000, 103.033000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 26.897500, 11.000000, 62.051000, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-14b : z axis, beta=11  chi, phi = -sigma, -tau, = -1.35, -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-14b : z axis, beta=11 chi, phi = -sigma, -tau, = -1.35, -106 ***.
+
+SIXC.2> setmode 14
+Still using Z-Axis with Beta fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> BETA=11
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(6.084000, 21.461000, 11.000000, -38.547500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 18.931000, 11.000000, -92.997500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 18.931000, 11.000000, -2.968000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 26.897500, 11.000000, -43.983000, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.1> com ***************  cubic from bliss tutorial ************
+
+Mon Jul 28 12:18:45 2008.  *************** cubic from bliss tutorial ************.
+
+SIXC.1> com *******************************************************
+
+Mon Jul 28 12:18:45 2008.  *******************************************************.
+
+SIXC.1> com *******************************************************
+
+Mon Jul 28 12:18:45 2008.  *******************************************************.
+
+SIXC.1> com *******************************************************
+
+Mon Jul 28 12:18:45 2008.  *******************************************************.
+
+SIXC.1> setmode 0
+Now using Omega fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.1> LAMBDA=1.54
+
+SIXC.1> setlat 1.54 1.54 1.54 90 90 90
+(UB recalculated from orientation reflections and lattice.)
+
+SIXC.1> 
+SIXC.1> mv mu 0; mv del 60;mv gam 0;mv th 30;mv chi 0 ;mv phi 0;
+
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> or0 1 0 0 ;
+(UB recalculated from orientation reflections and lattice.)
+
+SIXC.1> mv mu 0; mv del 60;mv gam 0;mv th 30;mv chi 0 ;mv phi -90;
+
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> 
+SIXC.1> or1 0 1 0;
+(UB recalculated from orientation reflections and lattice.)
+
+SIXC.1> g_sect=0
+
+SIXC.1> dofile("sixc_test_scenario_guts.mac")
+
+SIXC.2> Reading file "/mntdirect/_bliss/users/walton/sixc_test_scenario_guts.mac" (level 2).
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-0a : fixed omega = 0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-0a : fixed omega = 0 ***.
+
+SIXC.2> setmode 0
+Still using Omega fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0; OMEGA=0
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.669750, 0.000000, 59.834875, -48.747500, -52.125000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 0.000000, -90.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 45.000000, 0.000000, -45.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-0b : fixed omega = 15 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-0b : fixed omega = 15 ***.
+
+SIXC.2> setmode 0
+Still using Omega fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0; OMEGA=15
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.669750, 0.000000, 74.834875, -51.108000, -75.236500)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 45.000000, 0.000000, -15.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 45.000000, 0.000000, -105.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 60.000000, 0.000000, -60.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-1a : fixed phi = 0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-1a : fixed phi = 0 ***.
+
+SIXC.2> setmode 1
+Now using Phi fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0;
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.669750, 0.000000, 28.470190, -61.699000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, -60.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 0.000000, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-1b : fixed phi = 15 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-1b : fixed phi = 15 ***.
+
+SIXC.2> setmode 1
+Still using Phi fixed (four circle, Mu = Gamma = 0) mode.
+
+SIXC.2> mv mu 0;mv gam 0;
+
+SIXC.2> 
+SIXC.2> 
+SIXC.2> mv phi 15
+
+SIXC.2> 
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.669750, 0.000000, 22.424215, -71.174000, 15.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 15.000000, 0.000000, 15.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, -75.000000, 0.000000, 15.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, -15.000000, 0.000000, 15.000000)
+
+SIXC.2> 
+
+SIXC.2> com ****** azimuth fixed ******
+
+Mon Jul 28 12:18:45 2008.  ****** azimuth fixed ******.
+
+SIXC.2> com *** sixc-3a : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 90 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3a : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 90 ***.
+
+SIXC.2> setmode 3
+Now using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.670000, 0.000000, -120.165000, 131.252500, -52.125000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 90.000000, 180.000000, -120.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 90.000000, 180.000000, 150.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 90.000000, 180.000000, 180.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-3b : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 37 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3b : azimuth fixed (mu,gamma fixed), sigma=0, tau=0, azimuth = 37 ***.
+
+SIXC.2> setmode 3
+Still using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=37
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.670000, 0.000000, -155.174500, 113.380000, -112.592000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 120.000000, 127.000000, -90.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 120.000000, 127.000000, 180.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 135.000000, 127.000000, -135.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-3c : azimuth fixed (mu,gamma fixed), sigma=-1.35, tau=-106, azimuth = 90 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3c : azimuth fixed (mu,gamma fixed), sigma=-1.35, tau=-106, azimuth = 90 ***.
+
+SIXC.2> setmode 3
+Still using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.670000, 0.000000, -120.165000, 131.252500, -52.125000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 90.000000, 180.000000, -120.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 90.000000, 180.000000, 150.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 90.000000, 180.000000, 180.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-3d : azimuth fixed (mu,gamma fixed),  sigma=-1.35, tau=-106, azimuth = 37 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-3d : azimuth fixed (mu,gamma fixed), sigma=-1.35, tau=-106, azimuth = 37 ***.
+
+SIXC.2> setmode 3
+Still using Azimuth, Mu and Gamma fixed mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=37
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 119.670000, 0.000000, -155.174500, 113.380000, -112.592000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 120.000000, 127.000000, -90.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 120.000000, 127.000000, 180.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 135.000000, 127.000000, -135.000000)
+
+SIXC.2> 
+
+SIXC.2> com ****** z axiz, fixed azimuth ******
+
+Mon Jul 28 12:18:45 2008.  ****** z axiz, fixed azimuth ******.
+
+SIXC.2> com *** sixc-12a : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12a : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 12
+Now using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(40.541500, 97.212000, 40.541500, -3.519000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, -60.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, 0.000000, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-12b : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12b : z axis, azimuth=90 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***.
+
+SIXC.2> setmode 12
+Still using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=90
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(40.541500, 97.212000, 40.541500, -110.073500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, -75.996000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, -166.004000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 90.000000, 0.000000, -105.993500, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-12c : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12c : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 12
+Still using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> AZIMUTH=35
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(22.246000, 113.979000, 67.133500, 19.731500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-45.186500, 90.375500, 45.186500, 45.188000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-45.186500, 90.375500, 45.186500, -44.812000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-35.396500, 120.325000, 35.396500, 15.162500, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-12d : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-12d : z axis, azimuth=35 (Bin=Bout), chi, phi = -sigma, -tau, = -1.35 -106 ***.
+
+SIXC.2> setmode 12
+Still using Z-Axis with Azimuth fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> AZIMUTH=35
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(22.246000, 113.979000, 67.133500, -86.822500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-45.186500, 90.375500, 45.186500, -60.808000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-45.186500, 90.375500, 45.186500, -150.816500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-35.396500, 120.325000, 35.396500, -90.831000, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> com ***** z axis, fixed alpha/Bin beta/Bout*****
+
+Mon Jul 28 12:18:45 2008.  ***** z axis, fixed alpha/Bin beta/Bout*****.
+
+SIXC.2> com *** sixc-13a : z axis, alpha=10 (Bin=10), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-13a : z axis, alpha=10 (Bin=10), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 13
+Now using Z-Axis with Alpha fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> ALPHA=10
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 61.023500, -10.000000, 30.511500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 61.023500, -10.000000, -59.488500, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 91.781500, -10.000000, 0.891000, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-13b : z axis, alpha=10  chi, phi = -sigma, -tau, = -1.35, -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-13b : z axis, alpha=10 chi, phi = -sigma, -tau, = -1.35, -106 ***.
+
+SIXC.2> setmode 13
+Still using Z-Axis with Alpha fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> ALPHA=10
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 61.023500, -10.000000, -75.484000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 61.023500, -10.000000, -165.492500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(10.000000, 91.781500, -10.000000, -105.102500, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-14a : z axis, beta=11 (Bout=11), chi, phi = -sigma, -tau, = 0,0 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-14a : z axis, beta=11 (Bout=11), chi, phi = -sigma, -tau, = 0,0 ***.
+
+SIXC.2> setmode 14
+Now using Z-Axis with Beta fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau 0 0
+
+SIXC.2> 
+SIXC.2> mv chi 0
+
+SIXC.2> 
+SIXC.2> mv phi 0
+
+SIXC.2> 
+SIXC.2> BETA=11
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 61.242000, 11.000000, 30.621000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 61.242000, 11.000000, -59.379000, 0.000000, 0.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 92.165500, 11.000000, 1.082500, 0.000000, 0.000000)
+
+SIXC.2> 
+
+SIXC.2> com *** sixc-14b : z axis, beta=11  chi, phi = -sigma, -tau, = -1.35, -106 ***
+
+Mon Jul 28 12:18:45 2008.  *** sixc-14b : z axis, beta=11 chi, phi = -sigma, -tau, = -1.35, -106 ***.
+
+SIXC.2> setmode 14
+Still using Z-Axis with Beta fixed and Chi, Phi set to -Sigma, -Tau mode.
+
+SIXC.2> sigtau -1.35 -106
+
+SIXC.2> 
+SIXC.2> mv chi 1.35
+
+SIXC.2> 
+SIXC.2> mv phi 106
+
+SIXC.2> 
+SIXC.2> BETA=11
+
+SIXC.2> calcshow 0.7 0.9 1.3
+hkl = (0.700000, 0.900000, 1.300000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(0.000000, 60.000000, 0.000000, 30.000000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 0 0
+hkl = (1.000000, 0.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 61.242000, 11.000000, -75.374500, 1.350000, 106.000000)
+
+SIXC.2> calcshow 0 1 0
+hkl = (0.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 61.242000, 11.000000, -165.383000, 1.350000, 106.000000)
+
+SIXC.2> calcshow 1 1 0
+hkl = (1.000000, 1.000000, 0.000000)
+(alpha, delta, gamma, omega, chi, phi) = 
+(-11.000000, 92.165500, 11.000000, -104.910500, 1.350000, 106.000000)
+
+SIXC.2> 
+
+SIXC.2> 
+
+SIXC.1> off("output")
diff --git a/script/test/diffcalc (copy)/test/startup/__init__.py b/script/test/diffcalc (copy)/test/startup/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/startup/beamlinespecific/__init__.py b/script/test/diffcalc (copy)/test/startup/beamlinespecific/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/script/test/diffcalc (copy)/test/startup/beamlinespecific/i21.py b/script/test/diffcalc (copy)/test/startup/beamlinespecific/i21.py
new file mode 100644
index 0000000..552fa07
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/startup/beamlinespecific/i21.py	
@@ -0,0 +1,247 @@
+'''
+Created on 28 Feb 2017
+
+@author: zrb13439
+'''
+import unittest
+from diffcalc.gdasupport.scannable.mock import MockMotor
+from startup.beamlinespecific.i21 import I21SampleStage, calc_tp_lab,\
+    I21DiffractometerStage, I21TPLab, move_lab_origin_into_phi
+import mock
+from diffcalc.gdasupport.minigda.scannable import Scannable, ScannableBase
+from nose.tools import eq_
+from test.tools import assert_array_almost_equal as aneq_, aneq_
+from math import sqrt
+
+
+def mock_scannable(name='mock', pos=0):
+    scn = mock.Mock(ScannableBase)
+    scn.getName.return_value = name
+    scn.getPosition.return_value = pos
+    return scn
+
+
+class TestI21SampleStageBase(unittest.TestCase):
+
+    def setUp(self):
+        self.sapol = mock_scannable('sapol', 1)
+        self.satilt = mock_scannable('satilt', 2)
+        self.saaz = mock_scannable('saaz',3 )
+        self.xyz_eta = mock_scannable('xyz_eta', [10, 11, 12])
+
+        self.sa = I21SampleStage('sa', self.sapol, self.satilt, self.saaz,
+                                 self.xyz_eta)
+
+
+class TestI21SampleStageNoTp(TestI21SampleStageBase):
+        
+    def testGetInputNames(self):
+        eq_(self.sa.getInputNames(), ['sapol', 'satilt', 'saaz'])
+        
+    def testGetPosition(self):
+        eq_(self.sa.getPosition(), [1, 2, 3])
+        
+    def testAsynchronousMoveTo(self):
+        self.sa.asynchronousMoveTo([4, 5, 6])
+        self.sapol.asynchronousMoveTo.assert_called_with(4)
+        self.satilt.asynchronousMoveTo.assert_called_with(5)
+        self.saaz.asynchronousMoveTo.assert_called_with(6)
+        
+    def test__str__(self):
+        self.sa.tp_phi = [1, 2, 3]
+        self.sapol.getPosition.return_value = 0
+        self.satilt.getPosition.return_value = -90  # chi = 0
+        self.saaz.getPosition.return_value = 0
+        self.xyz_eta.getPosition.return_value = [10, 20, 30]
+        
+        print self.sa.__str__()
+        desired = \
+"""sa:                             
+sapolar:   0.00000 (eta)        tp_phi :  1.0000  2.0000  3.0000 (set)
+satilt:    -90.00000 (chi-90)   tp_lab : 11.0000 22.0000 33.0000
+saazimuth: 0.00000 (phi)        xyz_eta: 10.0000 20.0000 30.0000"""
+        result_lines = self.sa.__str__().split('\n')[0:4]
+        print 'Result:'
+        print '\n'.join(result_lines)
+        print '---'
+        eq_('\n'.join(result_lines), desired)
+        
+    def test_tp_scannable_get(self):
+        self.sa.tp_phi = [1, 2, 3]
+        eq_(self.sa.tp_phi_scannable.getPosition(), [1, 2, 3])
+        
+    def test_tp_scannable_set(self):
+        self.sa.tp_phi_scannable.asynchronousMoveTo([4, 5, 6])
+        eq_(self.sa.tp_phi, [4, 5, 6])
+
+
+class TestI21DiffractometerStage(unittest.TestCase):
+       
+    def setUp(self):
+        self.delta = mock_scannable('delta', 1 )
+        self.sa = mock_scannable('sa', [2, 3, 4]) 
+        self.fourc = I21DiffractometerStage('four', self.delta, self.sa, 90)
+        
+    def testGetPosition(self):
+        aneq_(self.fourc.getPosition(), [1, 2, 93, 4])
+
+    def testAsynchMoveToComplete(self):
+        self.fourc.asynchronousMoveTo([1, 2, 93, 4])
+        self.delta.asynchronousMoveTo.assert_called_with(1)
+        self.sa.asynchronousMoveTo.assert_called_with([2, 3, 4])
+
+    def testAsynchMoveToDeltaOnly(self):
+        self.fourc.asynchronousMoveTo([1, None, None, None])
+        self.delta.asynchronousMoveTo.assert_called_with(1)
+        self.sa.asynchronousMoveTo.assert_not_called()
+
+    def testAsynchMoveToEtaOnly(self):
+        self.fourc.asynchronousMoveTo([None, 2, None, None])
+        self.delta.asynchronousMoveTo.assert_not_called()
+        self.sa.asynchronousMoveTo.assert_called_with([2, None, None])
+
+    def testAsynchMoveToChiOnly(self):
+        self.fourc.asynchronousMoveTo([None, None, 93, None])
+        self.delta.asynchronousMoveTo.assert_not_called()
+        self.sa.asynchronousMoveTo.assert_called_with([None, 3, None])
+        
+ 
+class TestI21TPLab(unittest.TestCase):
+       
+    def setUp(self):
+        self.delta = mock_scannable('delta', 1 )
+        self.sa = mock.Mock()
+        self.sa.tp_phi = [1, 2, 3]
+        self.sa.xyz_eta_scn.getPosition.return_value = [10, 20, 30]
+        self.sa.getEulerPosition.return_value = [0, 0, 0]
+        self.tp_lab = I21TPLab('tp_lab', self.sa)
+        
+    def testGetPosition(self):
+        aneq_(self.tp_lab.getPosition(), [11, 22, 33])
+
+    def testAsynchMoveToComplete(self):
+        self.tp_lab.asynchronousMoveTo([11, 22, 33])
+        self.sa.xyz_eta_scn.asynchronousMoveTo.assert_called_with([10, 20, 30])              
+
+        
+
+class TestCalcTpLab_No_xyz_eta(unittest.TestCase):
+    
+    def test_calc_tp_lab__tp_phi_0(self):
+        eq_(calc_tp_lab([0, 0, 0], 0, 0, 0), [0, 0, 0])
+        eq_(calc_tp_lab([0, 0, 0], 1, 2, 3), [0, 0, 0])
+
+    def test_calc_tp_lab__lab_eq_phi_frame(self):
+        eq_(calc_tp_lab([1, 2, 3], 0, 0, 0), [1, 2, 3])
+
+    def test_calc_tp_lab__lab_z_parallel_to_phi_and_eta(self):
+        eq_(calc_tp_lab([0, 0, 1], 1, 0, 0), [0, 0, 1])
+        eq_(calc_tp_lab([0, 0, 1], 0, 0, 1), [0, 0, 1])
+        eq_(calc_tp_lab([0, 0, 1], 1, 0, 1), [0, 0, 1])
+        
+    def test_calc_tp_lab_eta0_chi90(self):
+        aneq_(calc_tp_lab([0, 0, 1], 0, 90, 0), [1, 0, 0]) 
+        aneq_(calc_tp_lab([0, 0, 1], 0, 90, 1), [1, 0, 0])
+        eq_(calc_tp_lab([0, 0, 1], 1, 0, 1), [0, 0, 1])
+        
+    def test_calc_tp_lab_eta0_eta90(self):
+        aneq_(calc_tp_lab([0, 1, 0], 90, 0, 0), [1, 0, 0]) 
+        aneq_(calc_tp_lab([0, 1, 0], 90, 1, 0), [1, 0, 0])
+
+    def test_calc_tp_lab_tp_phi_101(self):
+        aneq_(calc_tp_lab([1, 0, 1], 0, 45, 0), [sqrt(2), 0, 0]) 
+
+    def test_calc_tp_lab_tp_phi_110(self):
+        aneq_(calc_tp_lab([1, 1, 0], 45, 0, 0), [sqrt(2), 0, 0]) 
+        aneq_(calc_tp_lab([1, 1, 0], 0, 0, 45), [sqrt(2), 0, 0]) 
+        aneq_(calc_tp_lab([1, 1, 0], 46, 0, -1), [sqrt(2), 0, 0]) 
+        
+
+class TestCalcTpLabWithXyzEta(unittest.TestCase):
+    
+    def test_calc_tp_lab__tp_phi_0(self):
+        eq_(calc_tp_lab([0, 0, 0], 0, 0, 0, [0, 0, 0]), [0, 0, 0])
+        eq_(calc_tp_lab([0, 0, 0], 0, 0, 0, [4, 5, 6]), [4, 5, 6])
+        eq_(calc_tp_lab([10, 20, 30], 0, 0, 0, [1, 2, 3]), [11, 22, 33])
+
+    def test_calc_tp_lab__lab_eq_phi_frame(self):
+        eq_(calc_tp_lab([0, 0, 1], 0, 0, 99, [1, 2, 3]), [1, 2, 4])
+        eq_(calc_tp_lab([0, 0, 1], 0, 0, 99, [0, 0, 0]), [0, 0, 1])
+        eq_(calc_tp_lab([0, 0, 1], 1, 0, 99, [0, 0, 0]), [0, 0, 1])
+         
+    def test_calc_tp_lab_eta0_chi90(self):
+        aneq_(calc_tp_lab([0, 0, 1], 0, 90, 0, [0, 0, 0]), [1, 0, 0]) 
+        aneq_(calc_tp_lab([0, 0, 1], 0, 90, 1, [0, 0, 0]), [1, 0, 0])
+        aneq_(calc_tp_lab([0, 0, 1], 1, 00, 1, [0, 0, 0]), [0, 0, 1])
+#         
+#     def test_calc_tp_lab_eta0_eta90(self):
+#         aneq_(calc_tp_lab([0, 1, 0], 90, 0, 0), [1, 0, 0]) 
+#         aneq_(calc_tp_lab([0, 1, 0], 90, 1, 0), [1, 0, 0])
+# 
+#     def test_calc_tp_lab_tp_phi_101(self):
+#         aneq_(calc_tp_lab([1, 0, 1], 0, 45, 0), [sqrt(2), 0, 0]) 
+# 
+#     def test_calc_tp_lab_tp_phi_110(self):
+#         aneq_(calc_tp_lab([1, 1, 0], 45, 0, 0), [sqrt(2), 0, 0]) 
+#         aneq_(calc_tp_lab([1, 1, 0], 0, 0, 45), [sqrt(2), 0, 0]) 
+#         aneq_(calc_tp_lab([1, 1, 0], 46, 0, -1), [sqrt(2), 0, 0]) 
+#  
+class TestMoveLabOriginIntoPhi(unittest.TestCase):
+    
+    def test_xyz_eta_0(self):
+        aneq_(move_lab_origin_into_phi(0, 0, [0, 0, 0]), [0, 0, 0])
+        aneq_(move_lab_origin_into_phi(1, 2, [0, 0, 0]), [0, 0, 0])
+
+    def test_chi_phi_0(self):
+        aneq_(move_lab_origin_into_phi(0, 0, [1, 2, 3]), [-1, -2, -3])
+        aneq_(move_lab_origin_into_phi(0, 0, [-3, -2, -1]), [3, 2, 1])
+        
+    def test_stable_about_phi(self):
+        aneq_(move_lab_origin_into_phi(0, 99, [0, 0, 3]), [0, 0, -3])
+
+    def test_stable_about_chi(self):
+        aneq_(move_lab_origin_into_phi(99, 0, [0, 3, 0]), [0, -3, 0])
+
+    def test_rotate_about_phi(self):
+        aneq_(move_lab_origin_into_phi(0, 45, [0, 1, 4]),
+              [sqrt(.5), -sqrt(.5), -4])
+
+
+class TestI21SampleStageWithTP(TestI21SampleStageBase):
+    # Npte all are independent of eta
+    # Note tp_phi is the TARGET tool point to end up at the diffractometer centre
+    
+    def _move(self, tp_phi, pol, tilt, az):
+        self.sa.tp_phi = tp_phi
+        self.sa.asynchronousMoveTo([pol, tilt, az])
+
+    def _check(self, desired_xyz):
+        called_with_xyz = self.xyz_eta.asynchronousMoveTo.call_args[0][0]
+        aneq_(called_with_xyz, desired_xyz)
+    
+    def testAsynchronousMoveTo_tp_phi_0(self):
+        self._move([0, 0, 0], 99, 2 - 90, 3); self._check([0, 0, 0])
+        
+    def test_calc_tp_lab__tp_phi_0(self):
+        self._move([0, 0, 0], 99, 0 - 90, 0); self._check([0, 0, 0])
+        self._move([0, 0, 0], 99, 2 - 90, 3); self._check([0, 0, 0])
+  
+    def test_calc_tp_lab__lab_eq_phi_frame(self):
+        self._move([1, 2, 3], 99, 0 - 90, 0); self._check([-1, -2, -3])
+ 
+    def test_calc_tp_lab__lab_z_parallel_to_phi_and_eta(self):
+        self._move([0, 0, 1], 99, 0 - 90, 0); self._check([0, 0, -1])
+        self._move([0, 0, 1], 99, 0 - 90, 1); self._check([0, 0, -1])
+        self._move([0, 0, 1], 99, 0 - 90, 1); self._check([0, 0, -1])
+         
+    def test_calc_tp_lab_eta0_chi90(self):
+        self._move([0, 0, 1], 99, 90 - 90, 0); self._check([-1, 0, 0]) 
+        self._move([0, 0, 1], 99, 90 - 90, 1); self._check([-1, 0, 0])
+        self._move([0, 0, 1], 99, 0 - 90, 1); self._check([0, 0, -1])
+ 
+    def test_calc_tp_lab_tp_phi_101(self):
+        self._move([1, 0, 1], 99, 45 - 90, 0); self._check([-sqrt(2), 0, 0]) 
+# 
+    def test_calc_tp_lab_tp_phi_110(self):
+        self._move([1, 1, 0], 99, 0 - 90, 45); self._check([-sqrt(2), 0, 0]) 
+
diff --git a/script/test/diffcalc (copy)/test/test_numjy.py b/script/test/diffcalc (copy)/test/test_numjy.py
new file mode 100644
index 0000000..30d854a
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/test_numjy.py	
@@ -0,0 +1,245 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from nose.tools import eq_, ok_, assert_almost_equal  # @UnresolvedImport
+from nose.plugins.skip import SkipTest
+
+try:
+    import numpy
+    __NUMPY_AVAILABLE__ = True
+except ImportError:
+    __NUMPY_AVAILABLE__ = False
+try:
+    import numjy
+    import Jama
+    __NUMJY_AVAILABLE__ = True
+except ImportError:
+    __NUMJY_AVAILABLE__ = False
+
+from test.tools import assert_2darray_almost_equal, meq_
+
+
+class _TestNumpyMatrix():
+
+    def m(self, args):
+        raise NotImplementedError()
+
+    def test__init__(self):
+        m = self.m([[1, 2], [3, 4]])
+        meq_(self.m('1 2;3 4'), m)
+        meq_(self.m('1 2; 3 4'), m)
+        meq_(self.m('1, 2; 3, 4'), m)
+        meq_(self.m('1, 2; 3 4'), m)
+        meq_(self.m('1 ,  2;  3  4  '), m)
+        
+    def test__init__with_row_vector(self):
+        meq_(self.m([1, 2]), self.m([[1, 2]]))
+
+    def test_shape(self):
+        shape = self.m('1 2 3; 4 5 6').shape
+        eq_(len(shape), 2)
+        eq_(shape[0], 2)
+        eq_(shape[1], 3)
+
+    def test_len(self):
+        eq_(len(self.m('1 2 3; 4 5 6')), 2)
+
+    def test_2dslice(self):
+        m = self.m('0 1; 10 11')
+        eq_(m[0, 0], 00)
+        eq_(m[0, 1], 01)
+        eq_(m[1, 0], 10)
+        eq_(m[1, 1], 11)
+
+    def test_set_2dslice(self):
+        m = self.m('1 2; 3 4')
+        m[1, 1] = 40
+        meq_(m, self.m('1 2; 3 40'))
+
+    def test_tolist(self):
+        l = [[1, 2], [3, 4]]
+        assert_2darray_almost_equal(self.m(l).tolist(), l)
+
+    def test__str__(self):
+        eq_(str(self.m('1.234 2.; 3.1 4.')),
+            '[[ 1.234  2.   ]\n [ 3.1    4.   ]]')
+
+    def test__repr__(self):
+        eq_(repr(self.m('1. 2.; 3. 4.')),
+            'matrix([[ 1.,  2.],\n        [ 3.,  4.]])')
+
+    def test_all(self):
+        ok_(self.m([[True, True], [True, True]]).all())
+        ok_(not self.m([[True, False], [True, True]]).all())
+
+    def test_eq(self):
+        meq_(self.m('1 2; 3 4'),
+             self.m('1 2; 3 4.'))
+
+    def test_eq_false(self):
+        ok_(not (self.m('1 2; 3 4') == self.m('1 2; 3 5')).all())
+
+    def test__eq__(self):
+        meq_(self.m('1 2; 3 4') == self.m('1 2; 3 4.1'),
+             self.m([[True, True], [True, False]]))
+
+    def test__mul__matrix(self):
+        meq_(self.m('1 2; 3 4') * self.m('5 6; 7 8'),
+             self.m('19 22; 43 50'))
+
+    def test__mul__vector(self):
+        meq_(self.m('1 2; 3 4') * self.m('5; 7'),
+             self.m('19; 43'))
+
+    def test__mul__scaler(self):
+        meq_(self.m('1, 2; 3, 4') * 10,
+             self.m('10 20; 30 40'))
+
+    def test__sum__(self):
+        meq_(self.m('1 2; 3 4') + self.m('5 6; 7 8'),
+             self.m(' 6 8; 10 12'))
+
+    def test__sum__scaler(self):
+        meq_(self.m('1 2; 3 4') + 10,
+             self.m('11 12; 13 14'))
+
+    def test__sub__(self):
+        meq_(self.m('1 2; 3 4') - self.m('5 6; 7 8'),
+             self.m('-4 -4; -4 -4'))
+
+    def test__sub__scaler(self):
+        meq_(self.m('11 12; 13 14') - 10,
+             self.m('1 2; 3 4'))
+
+    def test__div__(self):
+        r = self.m('1 2; 3 4') / self.m('5. 6.; 7. 8.')
+        assert_almost_equal(r[0, 0], .2)
+        assert_almost_equal(r[0, 1], .33333333)
+        assert_almost_equal(r[1, 0], 0.42857143)
+        assert_almost_equal(r[1, 1], .5)
+
+    def test__div__scaler(self):
+        meq_(self.m('10 20; 30 40') / 10.,
+             self.m('1 2; 3 4'))
+
+    def test_I(self):
+        inverse = self.m('1 2; 3 4').I
+        assert_almost_equal(inverse[0, 0], -2)
+        assert_almost_equal(inverse[0, 1], 1)
+        assert_almost_equal(inverse[1, 0], 1.5)
+        assert_almost_equal(inverse[1, 1], -.5)
+
+    def test_T(self):
+        meq_(self.m('1 2; 3 4').T,
+             self.m('1 3; 2 4'))
+
+    def test_sum(self):
+        eq_(self.m('1 2; 3 4').sum(), 10)
+
+
+class _TestLinalg():
+
+    def matrix(self, args):
+        raise NotImplementedError()
+
+    def norm(self, args):
+        raise NotImplementedError()
+
+    def test_norm_frobenius(self):
+        m1 = self.matrix('1 1 1; 1 1 1; 1 1 1')
+        assert_almost_equal(self.norm(m1), 3, places=13)
+        m2 = self.matrix('1 2 3; 4 5 6; 7 8 9')
+        assert_almost_equal(self.norm(m2), 16.881943016134134, places=13)
+
+
+class _TestNumpy():
+
+    def matrix(self, args):
+        raise NotImplementedError()
+
+    def hstack(self, args):
+        raise NotImplementedError()
+
+    def test_hstack(self):
+        v1 = self.matrix('1;2;3')
+        v2 = self.matrix('4;5;6')
+        v3 = self.matrix('7;8;9')
+        meq_(self.hstack([v1, v2, v3]), self.matrix('1,4,7;2,5,8;3,6,9'))
+
+
+if __NUMPY_AVAILABLE__:
+
+    class TestNumpyMatrix(_TestNumpyMatrix):
+
+        def m(self, args):
+            return numpy.matrix(args)
+
+    class TestLinalgNumpy(_TestLinalg):
+
+        def matrix(self, args):
+            return numpy.matrix(args)
+
+        def norm(self, args):
+            return numpy.linalg.norm(args)
+
+    class TestNumpy(_TestNumpy):
+
+        def matrix(self, args):
+            return numpy.matrix(args)
+
+        def hstack(self, args):
+            return numpy.hstack(args)
+
+
+if __NUMJY_AVAILABLE__:
+
+    class TestNumjyMatrix(_TestNumpyMatrix):
+
+        def m(self, args):
+            return numjy.matrix(args)
+
+        def test__str__(self):
+            eq_(str(self.m('1.234 2.0; 3.1 4.0')),
+                '[[1.234  2.0]\n [3.1  4.0]]')
+
+        def test__repr__(self):
+            print repr(self.m('1. 2.; 3. 4.'))
+            eq_(repr(self.m('1. 2.; 3. 4.')),
+                'matrix([[1.0  2.0]\n        [3.0  4.0]])')
+
+        def test__div__(self):
+            raise SkipTest()
+
+    class TestLinalgNumjy(_TestLinalg):
+
+        def matrix(self, args):
+            return numjy.matrix(args)
+
+        def norm(self, args):
+            return numjy.linalg.norm(args)
+
+        def hstack(self, args):
+            return numjy.hstack(args)
+
+    class TestNumjy(_TestNumpy):
+
+        def matrix(self, args):
+            return numjy.matrix(args)
+
+        def hstack(self, args):
+            return numjy.hstack(args)
diff --git a/script/test/diffcalc (copy)/test/test_tools.py b/script/test/diffcalc (copy)/test/test_tools.py
new file mode 100644
index 0000000..c1e909c
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/test_tools.py	
@@ -0,0 +1,177 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from test.tools import assert_almost_equal, assert_array_almost_equal, \
+    assert_2darray_almost_equal, assert_matrix_almost_equal, \
+    assert_dict_almost_equal
+from nose.tools import eq_  # @UnresolvedImport
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+
+class test_assert_almost_equal():
+
+    def test_fails(self):
+        try:
+            assert_almost_equal(1, 1.0000001)
+            assert False
+        except AssertionError:
+#            eq_(e.args[0], '1 != 1.0000001000000001 within 7 places')
+            pass
+
+    def test__passes(self):
+        assert_almost_equal(1, 1.00000001)
+        assert_almost_equal(1, 1.0000001, 6)
+
+
+class test_assert_array_almost_equal():
+
+    def test__passes(self):
+        assert_array_almost_equal((1, 2, 3), (1.00000001, 2, 3.))
+        assert_array_almost_equal((1, 2, 3), (1.0000001, 2, 3.), 6)
+        assert_array_almost_equal((1, 2, 3), [1, 2, 3])
+        assert_array_almost_equal((), ())
+        assert_array_almost_equal([], ())
+
+    def test_wrong_length(self):
+        try:
+            assert_array_almost_equal((1, 2, 3), (1, 2))
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0], '(1, 2, 3) != (1, 2) as lengths differ')
+
+    def test_wrong_value(self):
+        try:
+            assert_array_almost_equal((3, 2, 1), (3, 2, 1.0000001))
+            assert False
+        except AssertionError:
+            pass
+
+
+class test_assert_2darray_almost_equal():
+
+    def test__passes(self):
+        assert_2darray_almost_equal(((1, 2), (3, 4)),
+                                    ((1.00000001, 2), (3, 4)))
+        assert_2darray_almost_equal(((1, 2), (3, 4)),
+                                    ((1.0000001, 2), (3, 4)), 6)
+        assert_2darray_almost_equal(((1, 2), (3, 4)),
+                                    [(1, 2), [3, 4]])
+        assert_2darray_almost_equal(((), ()), ((), ()))
+        assert_2darray_almost_equal([(), []], ([], ()))
+
+    def test_wrong_length(self):
+        try:
+            assert_2darray_almost_equal(((1, 2), (3, 4)), ((1, 2), (3, 4, 5)))
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0],
+                '((1, 2), (3, 4)) != ((1, 2), (3, 4, 5)) as sizes differ')
+
+    def test_wrong_value(self):
+        try:
+            assert_2darray_almost_equal(((1, 2), (3, 4)),
+                                        ((1.0000001, 2), (3, 4)))
+            assert False
+        except AssertionError:
+            pass
+
+
+class test_assert_matrix_almost_equal():
+
+    def test__passes(self):
+        assert_matrix_almost_equal(matrix([[1, 2], [3, 4]]),
+                                   matrix([[1.00000001, 2], [3, 4]]))
+        assert_matrix_almost_equal(matrix([[1, 2], [3, 4]]),
+                                   matrix([[1.0000001, 2], [3, 4]]), 6)
+
+    def test_wrong_length(self):
+        try:
+            assert_matrix_almost_equal(matrix([[1, 2], [3, 4]]),
+                                       matrix([[1, 2, 3], [4, 5, 6]]))
+            assert False
+        except AssertionError:
+            pass
+
+    def test_wrong_value(self):
+        try:
+            assert_matrix_almost_equal(matrix([[1, 2], [3, 4]]),
+                                        matrix([[1.0000001, 2], [3, 4]]))
+            assert False
+        except AssertionError:
+            pass
+
+
+class test_assert_dict_almost_equal():
+
+    def test__passes(self):
+        assert_dict_almost_equal({}, {})
+        assert_dict_almost_equal({'a': 1}, {'a': 1})
+        assert_dict_almost_equal({'a': 1.}, {'a': 1.})
+        assert_dict_almost_equal({'a': 1.00000001}, {'a': 1.00000001})
+
+    def test_wrong_keys(self):
+        try:
+            assert_dict_almost_equal({'a': 1}, {'a': 1, 'b': 2})
+            assert False
+        except AssertionError:
+            pass
+
+    def test_wrong_object(self):
+        try:
+            assert_dict_almost_equal({'a': 1}, {'a': '1'})
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0], "For key 'a', 1 != '1'")
+
+    def test_wrong_int(self):
+        try:
+            assert_dict_almost_equal({'a': 1}, {'a': 2})
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0], "For key 'a', 1 != 2")
+
+    def test_wrong_float1(self):
+        try:
+            assert_dict_almost_equal({'a': 1.}, {'a': 2.})
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0], "For key 'a', 1.0 != 2.0 within 7 places")
+
+    def test_wrong_float2(self):
+        try:
+            assert_dict_almost_equal({'a': 1}, {'a': 2.})
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0], "For key 'a', 1 != 2.0 within 7 places")
+
+    def test_wrong_float3(self):
+        try:
+            assert_dict_almost_equal({'a': 1.}, {'a': 2})
+            assert False
+        except AssertionError, e:
+            eq_(e.args[0], "For key 'a', 1.0 != 2 within 7 places")
+
+    def test_okay_differing_types1(self):
+        assert_dict_almost_equal({'a': 1.}, {'a': 1})
+
+    def test_okay_differing_types2(self):
+        assert_dict_almost_equal({'a': 1}, {'a': 1.})
diff --git a/script/test/diffcalc (copy)/test/tools.py b/script/test/diffcalc (copy)/test/tools.py
new file mode 100644
index 0000000..ea381e5
--- /dev/null
+++ b/script/test/diffcalc (copy)/test/tools.py	
@@ -0,0 +1,164 @@
+###
+# Copyright 2008-2011 Diamond Light Source Ltd.
+# This file is part of Diffcalc.
+#
+# Diffcalc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diffcalc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Diffcalc.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+from nose.tools import assert_almost_equal  # @UnresolvedImport
+from nose.tools import ok_
+from functools import wraps
+
+try:
+    from numpy import matrix
+except ImportError:
+    from numjy import matrix
+
+
+def format_note(note):
+    return " # %s" % note if note else ""
+
+
+def assert_array_almost_equal(first, second, places=7, msg=None, note=None):
+    err = "%r != %r as lengths differ%s" % (first, second, format_note(note))
+    assert len(first) == len(second), err
+    for f, s in zip(first, second):
+        default_msg = (
+            "\n%r != \n%r within %i places%s" % (format_array(first, places),
+            format_array(second, places), places, format_note(note)))
+        assert_almost_equal(f, s, places, msg or default_msg)
+
+
+def format_array(a, places):
+    fmt = '% .' + str(places) + 'f'
+    return '(' + ', '.join((fmt % el) for el in a) + ')'
+
+
+aneq_ = arrayeq_ = assert_array_almost_equal
+
+
+def assert_2darray_almost_equal(first, second, places=7, msg=None, note=None):
+    err = "%r != %r as sizes differ%s" % (first, second, format_note(note))
+    assert len(first) == len(second), err
+    for f2, s2 in zip(first, second):
+        err = "%r != %r as sizes differ%s" % (first, second, format_note(note))
+        assert len(f2) == len(s2), err
+        for f, s in zip(f2, s2):
+            message = "within %i places%s" % (places, format_note(note))
+            message += '\n' + format_2darray(first, places) + "!=\n"
+            message += format_2darray(second, places)
+            assert_almost_equal(f, s, places, msg or message)
+
+
+def format_2darray(array, places):
+    fmt = '% .' + str(places) + 'f'
+    s = ""
+    for row in array:
+        line = [fmt % el for el in row]
+        s += '[' + ', '.join(line) + ']\n'
+    return s
+
+
+def _array(m):
+    if isinstance(m, matrix):  # numpy
+        return m.tolist()
+    else:                       # assume Jama
+        return m.array
+
+
+def assert_matrix_almost_equal(first, second, places=7, msg=None, note=None):
+    assert_2darray_almost_equal(_array(first), _array(second), places, msg)
+
+
+def assert_dict_almost_equal(first, second, places=7, msg=None, note=None):
+    def_msg = "%r != %r as keys differ%s" % (first, second, format_note(note))
+    assert set(first.keys()) == set(second.keys()), msg or def_msg
+    keys = first.keys()
+    keys.sort()
+    for key in keys:
+        f = first[key]
+        s = second[key]
+        if isinstance(f, float) or isinstance(s, float):
+            def_msg = ("For key %s, %r != %r within %i places%s" %
+                       (repr(key), f, s, places, format_note(note)))
+            assert_almost_equal(f, s, places, msg or def_msg)
+        else:
+            if f != s:
+                raise AssertionError(
+                    "For key %s, %r != %r%s" %
+                    (repr(key), f, s, format_note(note)))
+
+dneq_ = assert_dict_almost_equal
+
+def assert_second_dict_almost_in_first(value, expected, places=7, msg=None):
+    value = value.copy()
+    for key in value.keys():
+        if key not in expected.keys():
+            del value[key]
+    assert_dict_almost_equal(value, expected, places=7, msg=None)
+
+
+def assert_iterable_almost_equal(first, second, places=7, msg=None, note=None):
+    def_msg = ("%r != %r as lengths differ%s" %
+               (first, second, format_note(note)))
+    assert len(first) == len(second), msg or def_msg
+    for f, s in zip(first, second):
+        if isinstance(f, float) or isinstance(s, float):
+            assert_almost_equal(f, s, places, msg)
+        else:
+            if f != s:
+                raise AssertionError("%r != %r%s" % (f, s, format_note(note)))
+
+
+mneq_ = matrixeq_ = assert_matrix_almost_equal
+
+
+def meq_(a, b):
+    ok_((a == b).all(), '\n%s\n  !=\n%s' % (a, b))
+
+
+def wrap_command_to_print_calls(f, user_syntax=True):
+
+    def print_with_user_syntax(f, args):
+        arg_strings = []
+        for arg in args:
+            if isinstance(arg, list):
+                element_as_strings = (str(el) for el in arg)
+                arg_strings.append('[%s]' % ' '.join(element_as_strings))
+            else:
+                try:
+                    arg_strings.append(arg.name)  # Scannable
+                except AttributeError:
+                    arg_strings.append(repr(arg))  # e.g. number or string
+
+        print '\n>>>', f.__name__, ' '.join(arg_strings)
+
+    def print_with_python_syntax(f, args):
+        print '\n>>> %s(%s)' % (f.__name__, ', '.join(args))
+
+    def print_and_call_command(f, args):
+        if user_syntax:
+            print_with_user_syntax(f, args)
+        else:
+            print_with_python_syntax(f, args)
+        result = f(*args)
+        if result is not None:
+            print result
+        return result
+
+    @wraps(f)
+    def wrapper(*args, **kwds):
+        return print_and_call_command(f, args)
+
+    return wrapper
diff --git a/script/test/diffcalc (copy)/todo.txt b/script/test/diffcalc (copy)/todo.txt
new file mode 100644
index 0000000..50a0c3e
--- /dev/null
+++ b/script/test/diffcalc (copy)/todo.txt	
@@ -0,0 +1,70 @@
+Complete restructure work:
+--------------------------
+
+Merge current mast in
+
+Make sure we can start the willmot engine - also dcwillmot differs from dcyou in only two places
+
+Fix and sure have tests (or delete startup files):
+
+	append_diffcalc_to_gda_jython_path.py
+	b16fivecircle.py
+	b16fourcircle_you_engine.py
+	i10fourcircle.py
+	sixcircle_api.py
+	sixcircle_vrmldummy.py
+	sixcircle.py
+
+Check for 3 failing math (at least on OSX):
+	- 
+
+Remove _diffcalc module:
+	- comment as you go!
+	- checkub -> add test to test_you.py
+	- fix the 'help ub' and 'help hkl' commands
+	- get hkl scannable working without _diffcalc
+
+
+Tidy:
+	- move sim logic off: DiffractometerScannableGroup 
+	- move example folder up into diffcalc.gdasupport package
+	- rewite documentaion to call actual code for tests
+	
+Improve:
+	- you.py should not skip creating any scannables for fixed constraints (or related ones) 
+
+Compare number of tests again branch point
+Decision not to dump vlieg mode
+why no integration test for willmott
+
+
+
+
+
+
+List needs review. Unordered. RobW.
+----------------------------------
+
+- look at all commands together (showref, listub, cons)
+
+- overide help command. Perhaps just print __doc__ if it starts with '!' or '@command'
+
+- error handling in wrapper. check TypeError depth. Give help inside exception string.
+
+- parameter scannables should return current virtual angle __str__ would also show requestd
+
+- remove need for axis_par scannables - set value, consider e.g. mu scan, and moved from epics. mu scan requires mu to be same level as hkl to work efficiently
+
+- implement mu_eq_nu mode
+
+- add eta_half_delta and mu_half_nu modes
+
+- provide fivec etc plugins (i13 first)
+
+- provide arbitrary virtual names (and check arbitray motor names work)
+
+- provide short cut mode access my number (beamline specific) ? Good idea?
+
+- handle eV / keV properly (wavelength internally, flag to energy_unit equal 'keV' (default) or 'eV'
+
+- Fix .__doc__ help on hkl (metaclass syetm fails under Jython with a java base class)
\ No newline at end of file
diff --git a/script/test/diffcalc (copy)/tox.ini b/script/test/diffcalc (copy)/tox.ini
new file mode 100644
index 0000000..5902cb2
--- /dev/null
+++ b/script/test/diffcalc (copy)/tox.ini	
@@ -0,0 +1,23 @@
+# Tox (https://tox.readthedocs.io/) is a tool for running tests
+# in multiple virtualenvs. This configuration file will run the
+# test suite on all supported python versions. To use it, "pip install tox"
+# and then run "tox" from this directory.
+#py27
+
+[tox]
+envlist = jython
+
+[testenv:jython]
+basepython=/Users/zrb13439/jython/bin/jython
+
+
+[testenv]
+commands =
+#	pytest
+#	py.test --boxed integration_checks.py
+#	diffcalc --help
+#	./diffcalc.py --modules
+# 	./diffcalc.py --non-interactive --python sixcircle
+#	./diffcalc.py --non-interactive sixcircle
+
+deps =