Index: src/sas/sascalc/dataloader/manipulations.py
===================================================================
--- src/sas/sascalc/dataloader/manipulations.py	(revision 3e5648b0f738718f823af66d5095c1cc74103d39)
+++ src/sas/sascalc/dataloader/manipulations.py	(revision 8e15dce248507a41ccb81ba9ea3a881f69a4e7c1)
@@ -14,5 +14,5 @@
 #TODO: copy the meta data from the 2D object to the resulting 1D object
 import math
-import numpy
+import numpy as np
 
 #from data_info import plottable_2D
@@ -82,6 +82,6 @@
     if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None:
         raise ValueError, "Can't convert this data: data=None..."
-    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1))
-    new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1))
+    new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1))
+    new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1))
     new_y = new_y.swapaxes(0, 1)
 
@@ -89,10 +89,10 @@
     qx_data = new_x.flatten()
     qy_data = new_y.flatten()
-    q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
-    if data2d.err_data is None or numpy.any(data2d.err_data <= 0):
-        new_err_data = numpy.sqrt(numpy.abs(new_data))
+    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
+    if data2d.err_data is None or np.any(data2d.err_data <= 0):
+        new_err_data = np.sqrt(np.abs(new_data))
     else:
         new_err_data = data2d.err_data.flatten()
-    mask = numpy.ones(len(new_data), dtype=bool)
+    mask = np.ones(len(new_data), dtype=bool)
 
     #TODO: make sense of the following two lines...
@@ -149,8 +149,8 @@
 
         # Get data
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
+        data = data2D.data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
 
         # Build array of Q intervals
@@ -170,8 +170,8 @@
             raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj)
 
-        x = numpy.zeros(nbins)
-        y = numpy.zeros(nbins)
-        err_y = numpy.zeros(nbins)
-        y_counts = numpy.zeros(nbins)
+        x = np.zeros(nbins)
+        y = np.zeros(nbins)
+        err_y = np.zeros(nbins)
+        y_counts = np.zeros(nbins)
 
         # Average pixelsize in q space
@@ -225,5 +225,5 @@
         y = y / y_counts
         x = x / y_counts
-        idx = (numpy.isfinite(y) & numpy.isfinite(x))
+        idx = (np.isfinite(y) & np.isfinite(x))
 
         if not idx.any():
@@ -304,8 +304,8 @@
             raise RuntimeError, msg
         # Get data
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
+        data = data2D.data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
 
         y = 0.0
@@ -414,8 +414,8 @@
         """
         # Get data W/ finite values
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        mask_data = data2D.mask[numpy.isfinite(data2D.data)]
+        data = data2D.data[np.isfinite(data2D.data)]
+        q_data = data2D.q_data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        mask_data = data2D.mask[np.isfinite(data2D.data)]
 
         dq_data = None
@@ -430,10 +430,11 @@
             z_max = max(data2D.q_data)
             z_min = min(data2D.q_data)
-            x_max = data2D.dqx_data[numpy.where(data2D.q_data == z_max)]
-            x_min = data2D.dqx_data[numpy.where(data2D.q_data == z_min)]
-            y_max = data2D.dqy_data[numpy.where(data2D.q_data == z_max)]
-            y_min = data2D.dqy_data[numpy.where(data2D.q_data == z_min)]
+            dqx_at_z_max = data2D.dqx_data[np.argmax(data2D.q_data)]
+            dqx_at_z_min = data2D.dqx_data[np.argmin(data2D.q_data)]
+            dqy_at_z_max = data2D.dqy_data[np.argmax(data2D.q_data)]
+            dqy_at_z_min = data2D.dqy_data[np.argmin(data2D.q_data)]
             # Find qdx at q = 0
-            dq_overlap_x = (x_min * z_max - x_max * z_min) / (z_max - z_min)
+            dq_overlap_x = ((dqx_at_z_min * z_max - dqx_at_z_max * z_min) /
+                            (z_max - z_min))
             # when extrapolation goes wrong
             if dq_overlap_x > min(data2D.dqx_data):
@@ -441,5 +442,6 @@
             dq_overlap_x *= dq_overlap_x
             # Find qdx at q = 0
-            dq_overlap_y = (y_min * z_max - y_max * z_min) / (z_max - z_min)
+            dq_overlap_y = ((dqy_at_z_min * z_max - dqy_at_z_max * z_min) /
+                            (z_max - z_min))
             # when extrapolation goes wrong
             if dq_overlap_y > min(data2D.dqy_data):
@@ -448,18 +450,18 @@
             dq_overlap_y *= dq_overlap_y
 
-            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
             # Final protection of dq
             if dq_overlap < 0:
-                dq_overlap = y_min
-            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)]
-            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap
+                dq_overlap = dqy_at_z_min
+            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)]
+            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap
             # def; dqx_data = dq_r dqy_data = dq_phi
             # Convert dq 2D to 1D here
             dqx = dqx_data * dqx_data
             dqy = dqy_data * dqy_data
-            dq_data = numpy.add(dqx, dqy)
-            dq_data = numpy.sqrt(dq_data)
-
-        #q_data_max = numpy.max(q_data)
+            dq_data = np.add(dqx, dqy)
+            dq_data = np.sqrt(dq_data)
+
+        #q_data_max = np.max(q_data)
         if len(data2D.q_data) is None:
             msg = "Circular averaging: invalid q_data: %g" % data2D.q_data
@@ -469,9 +471,9 @@
         nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width))
 
-        x = numpy.zeros(nbins)
-        y = numpy.zeros(nbins)
-        err_y = numpy.zeros(nbins)
-        err_x = numpy.zeros(nbins)
-        y_counts = numpy.zeros(nbins)
+        x = np.zeros(nbins)
+        y = np.zeros(nbins)
+        err_y = np.zeros(nbins)
+        err_x = np.zeros(nbins)
+        y_counts = np.zeros(nbins)
 
         for npt in range(len(data)):
@@ -527,8 +529,8 @@
 
         err_y = err_y / y_counts
-        err_y[err_y == 0] = numpy.average(err_y)
+        err_y[err_y == 0] = np.average(err_y)
         y = y / y_counts
         x = x / y_counts
-        idx = (numpy.isfinite(y)) & (numpy.isfinite(x))
+        idx = (np.isfinite(y)) & (np.isfinite(x))
 
         if err_x is not None:
@@ -585,15 +587,15 @@
 
         # Get data
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
+        data = data2D.data[np.isfinite(data2D.data)]
+        q_data = data2D.q_data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
 
         # Set space for 1d outputs
-        phi_bins = numpy.zeros(self.nbins_phi)
-        phi_counts = numpy.zeros(self.nbins_phi)
-        phi_values = numpy.zeros(self.nbins_phi)
-        phi_err = numpy.zeros(self.nbins_phi)
+        phi_bins = np.zeros(self.nbins_phi)
+        phi_counts = np.zeros(self.nbins_phi)
+        phi_values = np.zeros(self.nbins_phi)
+        phi_err = np.zeros(self.nbins_phi)
 
         # Shift to apply to calculated phi values in order
@@ -636,5 +638,5 @@
             phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i)
 
-        idx = (numpy.isfinite(phi_bins))
+        idx = (np.isfinite(phi_bins))
 
         if not idx.any():
@@ -769,9 +771,9 @@
 
         # Get the all data & info
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
+        data = data2D.data[np.isfinite(data2D.data)]
+        q_data = data2D.q_data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
         dq_data = None
 
@@ -785,10 +787,11 @@
             z_max = max(data2D.q_data)
             z_min = min(data2D.q_data)
-            x_max = data2D.dqx_data[numpy.where(data2D.q_data == z_max)]
-            x_min = data2D.dqx_data[numpy.where(data2D.q_data == z_min)]
-            y_max = data2D.dqy_data[numpy.where(data2D.q_data == z_max)]
-            y_min = data2D.dqy_data[numpy.where(data2D.q_data == z_min)]
+            dqx_at_z_max = data2D.dqx_data[np.argmax(data2D.q_data)]
+            dqx_at_z_min = data2D.dqx_data[np.argmin(data2D.q_data)]
+            dqy_at_z_max = data2D.dqy_data[np.argmax(data2D.q_data)]
+            dqy_at_z_min = data2D.dqy_data[np.argmin(data2D.q_data)]
             # Find qdx at q = 0
-            dq_overlap_x = (x_min * z_max - x_max * z_min) / (z_max - z_min)
+            dq_overlap_x = ((dqx_at_z_min * z_max - dqx_at_z_max * z_min) /
+                            (z_max - z_min))
             # when extrapolation goes wrong
             if dq_overlap_x > min(data2D.dqx_data):
@@ -796,5 +799,6 @@
             dq_overlap_x *= dq_overlap_x
             # Find qdx at q = 0
-            dq_overlap_y = (y_min * z_max - y_max * z_min) / (z_max - z_min)
+            dq_overlap_y = ((dqy_at_z_min * z_max - dqy_at_z_max * z_min) /
+                            (z_max - z_min))
             # when extrapolation goes wrong
             if dq_overlap_y > min(data2D.dqy_data):
@@ -803,22 +807,22 @@
             dq_overlap_y *= dq_overlap_y
 
-            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
             if dq_overlap < 0:
-                dq_overlap = y_min
-            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)]
-            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap
+                dq_overlap = dqy_at_z_min
+            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)]
+            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap
             # def; dqx_data = dq_r dqy_data = dq_phi
             # Convert dq 2D to 1D here
             dqx = dqx_data * dqx_data
             dqy = dqy_data * dqy_data
-            dq_data = numpy.add(dqx, dqy)
-            dq_data = numpy.sqrt(dq_data)
+            dq_data = np.add(dqx, dqy)
+            dq_data = np.sqrt(dq_data)
 
         #set space for 1d outputs
-        x = numpy.zeros(self.nbins)
-        y = numpy.zeros(self.nbins)
-        y_err = numpy.zeros(self.nbins)
-        x_err = numpy.zeros(self.nbins)
-        y_counts = numpy.zeros(self.nbins)
+        x = np.zeros(self.nbins)
+        y = np.zeros(self.nbins)
+        y_err = np.zeros(self.nbins)
+        x_err = np.zeros(self.nbins)
+        y_counts = np.zeros(self.nbins)
 
         # Get the min and max into the region: 0 <= phi < 2Pi
@@ -923,6 +927,6 @@
                 #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2)
                 x[i] = x[i] / y_counts[i]
-        y_err[y_err == 0] = numpy.average(y_err)
-        idx = (numpy.isfinite(y) & numpy.isfinite(y_err))
+        y_err[y_err == 0] = np.average(y_err)
+        idx = (np.isfinite(y) & np.isfinite(y_err))
         if x_err is not None:
             d_x = x_err[idx] / y_counts[idx]
@@ -1012,5 +1016,5 @@
         qx_data = data2D.qx_data
         qy_data = data2D.qy_data
-        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
 
         # check whether or not the data point is inside ROI
@@ -1113,5 +1117,5 @@
 
         # get phi from data
-        phi_data = numpy.arctan2(qy_data, qx_data)
+        phi_data = np.arctan2(qy_data, qx_data)
 
         # Get the min and max into the region: -pi <= phi < Pi
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/parameters_panel_slicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/parameters_panel_slicer.py	(revision 3e5648b0f738718f823af66d5095c1cc74103d39)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/parameters_panel_slicer.py	(revision 8e15dce248507a41ccb81ba9ea3a881f69a4e7c1)
@@ -193,5 +193,5 @@
                                            name="Append to file name:")
             append_tool_tip = "Files will be saved as <SlicerType><FileName>"
-            append_tool_tip += "<AppendToText>.xml"
+            append_tool_tip += "<AppendToText>.txt"
             self.append_name.SetToolTipString(append_tool_tip)
             self.append_name.SetValue(self.default_value)
@@ -417,8 +417,8 @@
                         data_dic[item] = plot.plots[item]
 
-        # Save files as XML
+        # Save files as Text
         for item, data1d in data_dic.iteritems():
             base = '.'.join(item.split('.')[:-1])
-            file_name = base + append + ".xml"
+            file_name = base + append + ".txt"
             save_to = evt.path + "\\" + file_name
             writer.write(save_to, data1d)
@@ -439,5 +439,6 @@
         :param file_list: list of loaded file names to send to fit
         """
-        if fit != FIT_OPTIONS[0] and file_list is not None:
+        if fit in FIT_OPTIONS and fit != FIT_OPTIONS[0] and \
+                        file_list is not None:
             # Set perspective to fitting
             int = self.data_panel.perspective_cbox.FindString("Fitting")
