Index: src/sas/sascalc/data_util/qsmearing.py
===================================================================
--- src/sas/sascalc/data_util/qsmearing.py	(revision c6728e196359ad8b7bc04cd8e4c5df3ca22ea55f)
+++ src/sas/sascalc/data_util/qsmearing.py	(revision 345e7e4a8c6f5977c8c07032553b5ab00bdf837d)
@@ -5,5 +5,5 @@
 #This software was developed by the University of Tennessee as part of the
 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
-#project funded by the US National Science Foundation.
+#project funded by the US National Science Foundation. 
 #See the license text in license.txt
 #copyright 2008, University of Tennessee
@@ -13,13 +13,7 @@
 import logging
 import sys
-from sasmodels import sesans
-import numpy as np  # type: ignore
-from numpy import pi, exp  # type: ignore
 
 from sasmodels.resolution import Slit1D, Pinhole1D
-from sasmodels.sesans import SESANS1D
 from sasmodels.resolution2d import Pinhole2D
-from src.sas.sascalc.data_util.nxsunit import Converter
-
 
 def smear_selection(data, model = None):
@@ -42,6 +36,4 @@
     # Sanity check. If we are not dealing with a SAS Data1D
     # object, just return None
-
-    # This checks for 2D data (does not throw exception because fail is common)
     if  data.__class__.__name__ not in ['Data1D', 'Theory1D']:
         if data == None:
@@ -50,5 +42,5 @@
             return None
         return Pinhole2D(data)
-    # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions)
+
     if  not hasattr(data, "dx") and not hasattr(data, "dxl")\
          and not hasattr(data, "dxw"):
@@ -56,26 +48,4 @@
 
     # Look for resolution smearing data
-    # This is the code that checks for SESANS data; it looks for the file loader
-    # TODO: change other sanity checks to check for file loader instead of data structure?
-    _found_sesans = False
-    #if data.dx is not None and data.meta_data['loader']=='SESANS':
-    if data.dx is not None and data.isSesans:
-        #if data.dx[0] > 0.0:
-        if numpy.size(data.dx[data.dx <= 0]) == 0:
-            _found_sesans = True
-        #if data.dx[0] <= 0.0:
-        if numpy.size(data.dx[data.dx <= 0]) > 0:
-            raise ValueError('one or more of your dx values are negative, please check the data file!')
-    if _found_sesans == True:
-        #Pre-compute the Hankel matrix (H)
-        qmax, qunits = data.sample.zacceptance
-        hankel=sesans.SesansTransform()
-        sesans.SesansTransform.set_transform(hankel,
-        SE = Converter(data._xunit)(data.x, "A"),
-        zaccept = Converter(qunits)(qmax, "1/A"),
-        Rmax = 10000000)
-        # Then return the actual transform, as if it were a smearing function
-        return PySmear(SESANS1D(data, hankel._H0, hankel._H, hankel.q), model)
-
     _found_resolution = False
     if data.dx is not None and len(data.dx) == len(data.x):
@@ -122,14 +92,5 @@
         self.model = model
         self.resolution = resolution
-        if hasattr(self.resolution, 'data'):
-            if self.resolution.data.meta_data['loader'] == 'SESANS': # Always True if file extension is '.ses'!
-                self.offset = 0
-            # This is default behaviour, for future resolution/transform functions this needs to be revisited.
-            else:
-                self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0])
-        else:
-            self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0])
-
-        #self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0])
+        self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0])
 
     def apply(self, iq_in, first_bin=0, last_bin=None):
@@ -165,5 +126,4 @@
         q[first:last+1].
         """
-
         q = self.resolution.q
         first = numpy.searchsorted(q, q_min)
Index: src/sas/sascalc/dataloader/data_info.py
===================================================================
--- src/sas/sascalc/dataloader/data_info.py	(revision 1fac6c09c8ab1f0c228d078ee755bc91242e2fdc)
+++ src/sas/sascalc/dataloader/data_info.py	(revision 345e7e4a8c6f5977c8c07032553b5ab00bdf837d)
@@ -25,4 +25,58 @@
 import numpy
 import math
+
+class plottable_sesans1D(object):
+    """
+    SESANS is a place holder for 1D SESANS plottables.
+
+    #TODO: This was directly copied from the plottables_1D. Modified Somewhat.
+    #Class has been updated.
+    """
+    # The presence of these should be mutually
+    # exclusive with the presence of Qdev (dx)
+    x = None
+    y = None
+    lam = None
+    dx = None
+    dy = None
+    dlam = None
+    ## Slit smearing length
+    dxl = None
+    ## Slit smearing width
+    dxw = None
+
+    # Units
+    _xaxis = ''
+    _xunit = ''
+    _yaxis = ''
+    _yunit = ''
+
+    def __init__(self, x, y, lam, dx=None, dy=None, dlam=None):
+#        print "SESANS plottable working"
+        self.x = numpy.asarray(x)
+        self.y = numpy.asarray(y)
+        self.lam = numpy.asarray(lam)
+        if dx is not None:
+            self.dx = numpy.asarray(dx)
+        if dy is not None:
+            self.dy = numpy.asarray(dy)
+        if dlam is not None:
+            self.dlam = numpy.asarray(dlam)
+
+    def xaxis(self, label, unit):
+        """
+        set the x axis label and unit
+        """
+        self._xaxis = label
+        self._xunit = unit
+
+    def yaxis(self, label, unit):
+        """
+        set the y axis label and unit
+        """
+        self._yaxis = label
+        self._yunit = unit
+
+
 class plottable_1D(object):
     """
@@ -40,9 +94,4 @@
     dxw = None
 
-    ## SESANS specific params (wavelengths for spin echo length calculation)
-
-    lam = None
-    dlam = None
-
     # Units
     _xaxis = ''
@@ -51,5 +100,5 @@
     _yunit = ''
 
-    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None):
+    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None):
         self.x = numpy.asarray(x)
         self.y = numpy.asarray(y)
@@ -62,8 +111,4 @@
         if dxw is not None:
             self.dxw = numpy.asarray(dxw)
-        if lam is not None:
-            self.lam = numpy.asarray(lam)
-        if dlam is not None:
-            self.dlam = numpy.asarray(dlam)
 
     def xaxis(self, label, unit):
@@ -691,29 +736,14 @@
         return self._perform_union(other)
 
-class Data1D(plottable_1D, DataInfo):
-    """
-    1D data class
-    """
-    #if plottable_1D.lam is None: # This means it's SANS data!
-     #   x_unit = '1/A'
-      #  y_unit = '1/cm'
-    #elif plottable_1D.lam is not None: # This means it's SESANS data!
-     #   x_unit = 'A'
-      #  y_unit = 'pol'
-    #else: # and if it's neither, you get punished!
-     #   raise(TypeError,'This is neither SANS nor SESANS data, what the hell are you doing??')
-
-    def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=False):
-        self.isSesans = isSesans
+class SESANSData1D(plottable_sesans1D, DataInfo):
+    """
+    SESANS 1D data class
+    """
+    x_unit = 'nm'
+    y_unit = 'pol'
+
+    def __init__(self, x=None, y=None, lam=None, dx=None, dy=None, dlam=None):
         DataInfo.__init__(self)
-        plottable_1D.__init__(self, x, y, dx, dy,None, None, lam, dlam)
-        if self.isSesans:
-            x_unit = 'A'
-            y_unit = 'pol'
-        elif not self.isSesans: # it's SANS data! (Could also be simple else statement, but i prefer exhaustive conditionals...-JHB)
-            x_unit = '1/A'
-            y_unit = '1/cm'
-        else: # and if it's neither, you get punished!
-            raise(TypeError,'This is neither SANS nor SESANS data, what the hell are you doing??')
+        plottable_sesans1D.__init__(self, x, y, lam, dx, dy, dlam)
 
     def __str__(self):
@@ -729,4 +759,60 @@
         return _str
 
+    def clone_without_data(self, length=0, clone=None):
+        """
+        Clone the current object, without copying the data (which
+        will be filled out by a subsequent operation).
+        The data arrays will be initialized to zero.
+
+        :param length: length of the data array to be initialized
+        :param clone: if provided, the data will be copied to clone
+        """
+        from copy import deepcopy
+        if clone is None or not issubclass(clone.__class__, Data1D):
+            x = numpy.zeros(length)
+            dx = numpy.zeros(length)
+            y = numpy.zeros(length)
+            dy = numpy.zeros(length)
+            clone = Data1D(x, y, dx=dx, dy=dy)
+
+        clone.title = self.title
+        clone.run = self.run
+        clone.filename = self.filename
+        clone.instrument = self.instrument
+        clone.notes = deepcopy(self.notes)
+        clone.process = deepcopy(self.process)
+        clone.detector = deepcopy(self.detector)
+        clone.sample = deepcopy(self.sample)
+        clone.source = deepcopy(self.source)
+        clone.collimation = deepcopy(self.collimation)
+        clone.trans_spectrum = deepcopy(self.trans_spectrum)
+        clone.meta_data = deepcopy(self.meta_data)
+        clone.errors = deepcopy(self.errors)
+
+        return clone
+
+class Data1D(plottable_1D, DataInfo):
+    """
+    1D data class
+    """
+    x_unit = '1/A'
+    y_unit = '1/cm'
+
+    def __init__(self, x, y, dx=None, dy=None):
+        DataInfo.__init__(self)
+        plottable_1D.__init__(self, x, y, dx, dy)
+
+    def __str__(self):
+        """
+        Nice printout
+        """
+        _str = "%s\n" % DataInfo.__str__(self)
+        _str += "Data:\n"
+        _str += "   Type:         %s\n" % self.__class__.__name__
+        _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit)
+        _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit)
+        _str += "   Length:       %g\n" % len(self.x)
+        return _str
+
     def is_slit_smeared(self):
         """
@@ -757,7 +843,5 @@
             y = numpy.zeros(length)
             dy = numpy.zeros(length)
-            lam = numpy.zeros(length)
-            dlam = numpy.zeros(length)
-            clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam )
+            clone = Data1D(x, y, dx=dx, dy=dy)
 
         clone.title = self.title
Index: src/sas/sascalc/dataloader/readers/sesans_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/sesans_reader.py	(revision a01af350a84a187cc8dad7f8e72ebcf348a35f96)
+++ src/sas/sascalc/dataloader/readers/sesans_reader.py	(revision 345e7e4a8c6f5977c8c07032553b5ab00bdf837d)
@@ -8,5 +8,5 @@
 import numpy
 import os
-from sas.sascalc.dataloader.data_info import Data1D
+from sas.sascalc.dataloader.data_info import SESANSData1D
 
 # Check whether we have a converter available
@@ -59,5 +59,14 @@
                     raise  RuntimeError, "sesans_reader: cannot open %s" % path
                 buff = input_f.read()
+#                print buff
                 lines = buff.splitlines()
+#                print lines
+                #Jae could not find python universal line spliter:
+                #keep the below for now
+                # some ascii data has \r line separator,
+                # try it when the data is on only one long line
+#                if len(lines) < 2 :
+#                    lines = buff.split('\r')
+                 
                 x  = numpy.zeros(0)
                 y  = numpy.zeros(0)
@@ -74,7 +83,24 @@
                 tdlam = numpy.zeros(0)
                 tdx = numpy.zeros(0)
-                output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True )
+#                print "all good"
+                output = SESANSData1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam)
+#                print output                
                 self.filename = output.filename = basename
 
+#                #Initialize counters for data lines and header lines.
+#                is_data = False  # Has more than 5 lines
+#                # More than "5" lines of data is considered as actual
+#                # data unless that is the only data
+#                mum_data_lines = 5
+#                # To count # of current data candidate lines
+#                i = -1
+#                # To count total # of previous data candidate lines
+#                i1 = -1
+#                # To count # of header lines
+#                j = -1
+#                # Helps to count # of header lines
+#                j1 = -1
+#                #minimum required number of columns of data; ( <= 4).
+#                lentoks = 2
                 paramnames=[]
                 paramvals=[]
@@ -85,4 +111,6 @@
                 Pvals=[]
                 dPvals=[]
+#                print x
+#                print zvals
                 for line in lines:
                     # Initial try for CSV (split on ,)
@@ -94,9 +122,9 @@
                     if len(toks)>5:
                         zvals.append(toks[0])
-                        dzvals.append(toks[3])
-                        lamvals.append(toks[4])
-                        dlamvals.append(toks[5])
-                        Pvals.append(toks[1])
-                        dPvals.append(toks[2])
+                        dzvals.append(toks[1])
+                        lamvals.append(toks[2])
+                        dlamvals.append(toks[3])
+                        Pvals.append(toks[4])
+                        dPvals.append(toks[5])
                     else:
                         continue
@@ -112,8 +140,6 @@
                 default_z_unit = "A"
                 data_conv_P = None
-                default_p_unit = " " # Adjust unit for axis (L^-3)
+                default_p_unit = " "
                 lam_unit = lam_header[1].replace("[","").replace("]","")
-                if lam_unit == 'AA':
-                    lam_unit = 'A'
                 varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]]
                 valrange=range(1, len(zvals))
@@ -135,5 +161,4 @@
                 output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit)
                 output.y = y
-                output.y_unit = '\AA^{-2} cm^{-1}' # output y_unit erbij
                 output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit)
                 output.dy = dy
@@ -141,14 +166,14 @@
                 output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit)
 
-                output.xaxis("\\rm{z}", output.x_unit)
-                output.yaxis("\\rm{ln(P)/(t \lambda^2)}", output.y_unit) # Adjust label to ln P/(lam^2 t), remove lam column refs
+                output.xaxis("\rm{z}", output.x_unit)
+                output.yaxis("\\rm{P/P0}", output.y_unit)
                 # Store loading process information
                 output.meta_data['loader'] = self.type_name
-                #output.sample.thickness = float(paramvals[6])
+                output.sample.thickness = float(paramvals[6])
                 output.sample.name = paramvals[1]
                 output.sample.ID = paramvals[0]
                 zaccept_unit_split = paramnames[7].split("[")
                 zaccept_unit = zaccept_unit_split[1].replace("]","")
-                if zaccept_unit.strip() == '\AA^-1' or zaccept_unit.strip() == '\A^-1':
+                if zaccept_unit.strip() == '\AA^-1':
                     zaccept_unit = "1/A"
                 output.sample.zacceptance=(float(paramvals[7]),zaccept_unit)
Index: src/sas/sascalc/fit/AbstractFitEngine.py
===================================================================
--- src/sas/sascalc/fit/AbstractFitEngine.py	(revision 79885018e2047aef9517748c8de7eccc28d1305e)
+++ src/sas/sascalc/fit/AbstractFitEngine.py	(revision 345e7e4a8c6f5977c8c07032553b5ab00bdf837d)
@@ -131,5 +131,5 @@
         a way to get residuals from data.
     """
-    def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None, lam=None, dlam=None):
+    def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None):
         """
             :param smearer: is an object of class QSmearer or SlitSmearer
@@ -152,5 +152,5 @@
                 
         """
-        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy, lam=lam,dlam=dlam)
+        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy)
         self.num_points = len(x)
         self.sas_data = data
Index: src/sas/sascalc/fit/BumpsFitting.py
===================================================================
--- src/sas/sascalc/fit/BumpsFitting.py	(revision 1a5d5f2d6cd4b4999b40c7fbc72a7a295fa78d9d)
+++ src/sas/sascalc/fit/BumpsFitting.py	(revision 345e7e4a8c6f5977c8c07032553b5ab00bdf837d)
@@ -27,4 +27,5 @@
 from bumps import parameter
 from bumps.fitproblem import FitProblem
+
 
 from sas.sascalc.fit.AbstractFitEngine import FitEngine
