Index: DataLoader/data_info.py
===================================================================
--- DataLoader/data_info.py	(revision b39c817abd04851d62b16436a6591cd1b1d7fa0c)
+++ DataLoader/data_info.py	(revision 99d1af6082f75428716f6bace3bc5a668ba7a9b6)
@@ -26,5 +26,5 @@
 import math
 
-class Data2D:
+class plottable_2D:
     """
         Data2D is a place holder for 2D plottables, which are 
@@ -35,6 +35,31 @@
     ymin = None
     ymax = None
-    image = None
-  
+    data = None
+    err_data = None
+    
+    # Units
+    _xaxis = ''
+    _xunit = ''
+    _yaxis = ''
+    _yunit = ''
+    _zaxis = ''
+    _zunit = ''
+    
+    def __init__(self, data=None, err_data=None):
+        self.data = data
+        self.err_data = err_data
+        
+    def xaxis(self, label, unit):
+        self._xaxis = label
+        self._xunit = unit
+        
+    def yaxis(self, label, unit):
+        self._yaxis = label
+        self._yunit = unit
+            
+    def zaxis(self, label, unit):
+        self._zaxis = label
+        self._zunit = unit
+            
 class Vector:
     """
@@ -80,5 +105,5 @@
     orientation = Vector()
     orientation_unit = 'degree'
-    ## Center of the beam on the detector in X and Y (and Z if necessary) [Vector] [pixel]
+    ## Center of the beam on the detector in X and Y (and Z if necessary) [Vector] [mm]
     beam_center = Vector()
     beam_center_unit = 'mm'
@@ -282,107 +307,4 @@
     errors = []
             
-    # Private method to perform operation. Not implemented for DataInfo,
-    # but should be implemented for each data class inherited from DataInfo
-    # that holds actual data (ex.: Data1D)
-    def _perform_operation(self, other, operation): return NotImplemented
-
-    def __add__(self, other):
-        """
-            Add two data sets
-            
-            @param other: data set to add to the current one
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return a+b
-        return self._perform_operation(other, operation)
-        
-    def __radd__(self, other):
-        """
-            Add two data sets
-            
-            @param other: data set to add to the current one
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return b+a
-        return self._perform_operation(other, operation)
-        
-    def __sub__(self, other):
-        """
-            Subtract two data sets
-            
-            @param other: data set to subtract from the current one
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return a-b
-        return self._perform_operation(other, operation)
-        
-    def __rsub__(self, other):
-        """
-            Subtract two data sets
-            
-            @param other: data set to subtract from the current one
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return b-a
-        return self._perform_operation(other, operation)
-        
-    def __mul__(self, other):
-        """
-            Multiply two data sets
-            
-            @param other: data set to subtract from the current one
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return a*b
-        return self._perform_operation(other, operation)
-        
-    def __rmul__(self, other):
-        """
-            Multiply two data sets
-            
-            @param other: data set to subtract from the current one
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return b*a
-        return self._perform_operation(other, operation)
-        
-    def __div__(self, other):
-        """
-            Divided a data set by another
-            
-            @param other: data set that the current one is divided by
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return a/b
-        return self._perform_operation(other, operation)
-        
-    def __rdiv__(self, other):
-        """
-            Divided a data set by another
-            
-            @param other: data set that the current one is divided by
-            @return: new data set
-            @raise ValueError: raised when two data sets are incompatible
-        """
-        def operation(a, b): return b/a
-        return self._perform_operation(other, operation)            
-            
-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):
-        plottable_1D.__init__(self, x, y, dx, dy)
-        
     def __str__(self):
         """
@@ -403,5 +325,116 @@
         for item in self.notes:
             _str += "%s\n" % str(item)
-        
+
+        return _str
+            
+    # Private method to perform operation. Not implemented for DataInfo,
+    # but should be implemented for each data class inherited from DataInfo
+    # that holds actual data (ex.: Data1D)
+    def _perform_operation(self, other, operation): return NotImplemented
+
+    def __add__(self, other):
+        """
+            Add two data sets
+            
+            @param other: data set to add to the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return a+b
+        return self._perform_operation(other, operation)
+        
+    def __radd__(self, other):
+        """
+            Add two data sets
+            
+            @param other: data set to add to the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return b+a
+        return self._perform_operation(other, operation)
+        
+    def __sub__(self, other):
+        """
+            Subtract two data sets
+            
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return a-b
+        return self._perform_operation(other, operation)
+        
+    def __rsub__(self, other):
+        """
+            Subtract two data sets
+            
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return b-a
+        return self._perform_operation(other, operation)
+        
+    def __mul__(self, other):
+        """
+            Multiply two data sets
+            
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return a*b
+        return self._perform_operation(other, operation)
+        
+    def __rmul__(self, other):
+        """
+            Multiply two data sets
+            
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return b*a
+        return self._perform_operation(other, operation)
+        
+    def __div__(self, other):
+        """
+            Divided a data set by another
+            
+            @param other: data set that the current one is divided by
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return a/b
+        return self._perform_operation(other, operation)
+        
+    def __rdiv__(self, other):
+        """
+            Divided a data set by another
+            
+            @param other: data set that the current one is divided by
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        """
+        def operation(a, b): return b/a
+        return self._perform_operation(other, operation)            
+            
+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):
+        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__
@@ -502,2 +535,36 @@
         return result
         
+class Data2D(plottable_2D, DataInfo):
+    """
+        2D data class
+    """
+    ## Units for Q-values
+    Q_unit = '1/A'
+    
+    ## Units for I(Q) values
+    I_unit = '1/cm'
+    
+    ## Vector of Q-values at the center of each bin in x
+    x_bins = []
+    
+    ## Vector of Q-values at the center of each bin in y
+    y_bins = []
+    
+    
+    def __init__(self, data=None, err_data=None):
+        plottable_2D.__init__(self, data, err_data)
+
+    def __str__(self):
+        _str =  "%s\n" % DataInfo.__str__(self)
+        
+        _str += "Data:\n"
+        _str += "   Type:         %s\n" % self.__class__.__name__
+        _str += "   X- & Y-axis:  %s\t[%s]\n" % (self._yaxis, self._yunit)
+        _str += "   Z-axis:       %s\t[%s]\n" % (self._zaxis, self._zunit)
+        leny = 0
+        if len(self.data)>0:
+            leny = len(self.data[0])
+        _str += "   Length:       %g x %g\n" % (len(self.data), leny)
+        
+        return _str
+  
Index: DataLoader/readers/abs_reader.py
===================================================================
--- DataLoader/readers/abs_reader.py	(revision 8780e9a7e98f59c06b1819f1e068b7e84f496efc)
+++ DataLoader/readers/abs_reader.py	(revision 99d1af6082f75428716f6bace3bc5a668ba7a9b6)
@@ -11,6 +11,12 @@
 import numpy
 import os
-from DataLoader.data_info import Data1D
-
+from DataLoader.data_info import Data1D, Detector
+
+has_converter = True
+try:
+    from data_util.nxsunit import Converter
+except:
+    has_converter = False
+    
 class Reader:
     """
@@ -45,4 +51,6 @@
                 dy = numpy.zeros(0)
                 output = Data1D(x, y, dy=dy)
+                detector = Detector()
+                output.detector.append(detector)
                 self.filename = output.filename = basename
                 
@@ -50,4 +58,17 @@
                 is_center = False
                 is_data_started = False
+                
+                data_conv_q = None
+                data_conv_i = None
+                
+                if has_converter == True and output.x_unit != '1/A':
+                    data_conv_q = Converter('1/A')
+                    # Test it
+                    data_conv_q(1.0, output.x_unit)
+                    
+                if has_converter == True and output.y_unit != '1/cm':
+                    data_conv_i = Converter('1/cm')
+                    # Test it
+                    data_conv_i(1.0, output.y_unit)
                 
                 for line in lines:
@@ -60,5 +81,10 @@
                         # Wavelength in Angstrom
                         try:
-                            output.source.wavelength = float(line_toks[1])
+                            value = float(line_toks[1])
+                            if has_converter==True and output.source.wavelength_unit != 'A':
+                                conv = Converter('A')
+                                output.source.wavelength = conv(value, units=output.source.wavelength_unit)
+                            else:
+                                output.source.wavelength = value
                         except:
                             raise ValueError,"IgorReader: can't read this file, missing wavelength"
@@ -66,9 +92,14 @@
                         # Distance in meters
                         try:
-                            output.detector.distance = float(line_toks[3])*1000.0
+                            value = float(line_toks[3])
+                            if has_converter==True and detector.distance_unit != 'm':
+                                conv = Converter('m')
+                                detector.distance = conv(value, units=detector.distance_unit)
+                            else:
+                                detector.distance = value
                         except:
                             raise ValueError,"IgorReader: can't read this file, missing distance"
                         
-                        # Transmission
+                        # Transmission 
                         try:
                             output.sample.transmission = float(line_toks[4])
@@ -77,7 +108,12 @@
                             pass
                     
-                        # Thickness
-                        try:
-                            output.sample.thickness = float(line_toks[5])
+                        # Thickness in mm
+                        try:
+                            value = float(line_toks[5])
+                            if has_converter==True and output.sample.thickness_unit != 'mm':
+                                conv = Converter('mm')
+                                output.sample.thickness = conv(value, units=output.sample.thickness_unit)
+                            else:
+                                output.sample.thickness = value
                         except:
                             # Thickness is not a mandatory entry
@@ -95,10 +131,27 @@
                         center_x = float(line_toks[0])
                         center_y = float(line_toks[1])
-                        output.detector.beam_center.x = center_x
-                        output.detector.beam_center.y = center_y
+                        
+                        # Bin size
+                        if has_converter==True and detector.pixel_size_unit != 'mm':
+                            conv = Converter('mm')
+                            detector.pixel_size.x = conv(5.0, units=detector.pixel_size_unit)
+                            detector.pixel_size.y = conv(5.0, units=detector.pixel_size_unit)
+                        else:
+                            detector.pixel_size.x = 5.0
+                            detector.pixel_size.y = 5.0
+                        
+                        # Store beam center in distance units
+                        # Det 640 x 640 mm
+                        if has_converter==True and detector.beam_center_unit != 'mm':
+                            conv = Converter('mm')
+                            detector.beam_center.x = conv(center_x*5.0, units=detector.beam_center_unit)
+                            detector.beam_center.y = conv(center_y*5.0, units=detector.beam_center_unit)
+                        else:
+                            detector.beam_center.x = center_x*5.0
+                            detector.beam_center.y = center_y*5.0
                         
                         # Detector type
                         try:
-                            output.detector.name = line_toks[7]
+                            detector.name = line_toks[7]
                         except:
                             # Detector name is not a mandatory entry
@@ -116,4 +169,11 @@
                             _y  = float(toks[1]) 
                             _dy = float(toks[2])
+                            
+                            if data_conv_q is not None:
+                                _x = data_conv_q(_x, units=output.x_unit)
+                                
+                            if data_conv_i is not None:
+                                _y = data_conv_i(_y, units=output.y_unit)
+                                _dy = data_conv_i(_dy, units=output.y_unit)
                            
                             x  = numpy.append(x,   _x) 
@@ -142,6 +202,12 @@
                 output.y = y
                 output.dy = dy
-                output.xaxis("\\rm{Q}", 'A^{-1}')
-                output.yaxis("\\rm{I(Q)}","cm^{-1}")
+                if data_conv_q is not None:
+                    output.xaxis("\\rm{Q}", output.x_unit)
+                else:
+                    output.xaxis("\\rm{Q}", 'A^{-1}')
+                if data_conv_i is not None:
+                    output.yaxis("\\{I(Q)}", output.y_unit)
+                else:
+                    output.yaxis("\\rm{I(Q)}","cm^{-1}")
                 
                 return output
Index: DataLoader/readers/ascii_reader.py
===================================================================
--- DataLoader/readers/ascii_reader.py	(revision 4d2a0d1aafbbbc016ec13c2b0714497e8eb3a94a)
+++ DataLoader/readers/ascii_reader.py	(revision 99d1af6082f75428716f6bace3bc5a668ba7a9b6)
@@ -12,4 +12,10 @@
 import os
 from DataLoader.data_info import Data1D
+
+has_converter = True
+try:
+    from data_util.nxsunit import Converter
+except:
+    has_converter = False
 
 class Reader:
@@ -47,4 +53,18 @@
                 output = Data1D(x, y, dy=dy)
                 self.filename = output.filename = basename
+           
+                data_conv_q = None
+                data_conv_i = None
+                
+                if has_converter == True and output.x_unit != '1/A':
+                    data_conv_q = Converter('1/A')
+                    # Test it
+                    data_conv_q(1.0, output.x_unit)
+                    
+                if has_converter == True and output.y_unit != '1/cm':
+                    data_conv_i = Converter('1/cm')
+                    # Test it
+                    data_conv_i(1.0, output.y_unit)
+           
                 
                 # The first good line of data will define whether
@@ -58,4 +78,10 @@
                         _y = float(toks[1])
                         
+                        if data_conv_q is not None:
+                            _x = data_conv_q(_x, units=output.x_unit)
+                            
+                        if data_conv_i is not None:
+                            _y = data_conv_i(_y, units=output.y_unit)                        
+                        
                         # If we have an extra token, check
                         # whether it can be interpreted as a
@@ -65,4 +91,8 @@
                             try:
                                 _dy = float(toks[2])
+                                
+                                if data_conv_i is not None:
+                                    _dy = data_conv_i(_dy, units=output.y_unit)
+                                
                             except:
                                 # The third column is not a float, skip it.
@@ -96,7 +126,12 @@
                 output.y = y
                 output.dy = dy if has_error == True else None
-                output.xaxis("\\rm{Q}", 'A^{-1}')
-                output.yaxis("\\rm{I(Q)}","cm^{-1}")
-                
+                if data_conv_q is not None:
+                    output.xaxis("\\rm{Q}", output.x_unit)
+                else:
+                    output.xaxis("\\rm{Q}", 'A^{-1}')
+                if data_conv_i is not None:
+                    output.yaxis("\\{I(Q)}", output.y_unit)
+                else:
+                    output.yaxis("\\rm{I(Q)}","cm^{-1}")
                 
                 return output
Index: DataLoader/readers/cansas_reader.py
===================================================================
--- DataLoader/readers/cansas_reader.py	(revision b39c817abd04851d62b16436a6591cd1b1d7fa0c)
+++ DataLoader/readers/cansas_reader.py	(revision 99d1af6082f75428716f6bace3bc5a668ba7a9b6)
@@ -426,7 +426,13 @@
         data_info.dx = dx
         data_info.dy = dy
-        data_info.xaxis("\\rm{Q}", 'A^{-1}')
-        data_info.yaxis("\\rm{I(Q)}","cm^{-1}")
-
+        if data_conv_q is not None:
+            data_info.xaxis("\\rm{Q}", output.x_unit)
+        else:
+            data_info.xaxis("\\rm{Q}", 'A^{-1}')
+        if data_conv_i is not None:
+            data_info.yaxis("\\{I(Q)}", output.y_unit)
+        else:
+            data_info.yaxis("\\rm{I(Q)}","cm^{-1}")
+        
         return data_info
 
Index: DataLoader/readers/danse_reader.py
===================================================================
--- DataLoader/readers/danse_reader.py	(revision 68f6ae249434566dbc018908720451e6f12c11ca)
+++ DataLoader/readers/danse_reader.py	(revision 99d1af6082f75428716f6bace3bc5a668ba7a9b6)
@@ -1,11 +1,19 @@
 """
-    Test plug-in
+    DANSE/SANS file reader
 """
 
 import math
-import pylab
+import os
 import copy
 import numpy
 import logging
+from DataLoader.data_info import Data2D, Detector
+
+# Look for unit converter
+has_converter = True
+try:
+    from data_util.nxsunit import Converter
+except:
+    has_converter = False
 
 class Reader:
@@ -54,4 +62,25 @@
             fversion   = 1.0
             
+            output = Data2D()
+            output.filename = os.path.basename(filename)
+            detector = Detector()
+            output.detector.append(detector)
+            
+            output.data = numpy.zeros([size_x,size_y])
+            output.err_data = numpy.zeros([size_x,size_y])
+            
+            data_conv_q = None
+            data_conv_i = None
+            
+            if has_converter == True and output.Q_unit != '1/A':
+                data_conv_q = Converter('1/A')
+                # Test it
+                data_conv_q(1.0, output.Q_unit)
+                
+            if has_converter == True and output.I_unit != '1/cm':
+                data_conv_i = Converter('1/cm')
+                # Test it
+                data_conv_i(1.0, output.I_unit)            
+        
             read_on = True
             while read_on:
@@ -63,6 +92,6 @@
                 if toks[0]=="FORMATVERSION":
                     fversion = float(toks[1])
-                if toks[0]=="WAVELENGTH":
-                    wavelength = float(toks[1])
+                if toks[0]=="WAVELENGTH":    
+                    wavelength = float(toks[1])                
                 elif toks[0]=="DISTANCE":
                     distance = float(toks[1])
@@ -95,10 +124,11 @@
                             val = float(toks[0])
                             err = float(toks[1])
+                            if data_conv_i is not None:
+                                val = data_conv_i(val, units=output.y_unit)
+                                err = data_conv_i(err, units=output.y_unit)
                             data.append(val)
                             error.append(err)
                         except:
                             logging.info("Skipping line:%s,%s" %( data_str,sys.exc_value))
-                            #print "Skipping line:%s" % data_str
-                            #print sys.exc_value
             
             # Initialize 
@@ -109,12 +139,10 @@
             xmin = None
             xmax = None
-            Z = None
-        
-            
-            x = numpy.zeros(size_x)
-            y = numpy.zeros(size_y)
-            X, Y = pylab.meshgrid(x, y)
-            Z = copy.deepcopy(X)
-            E = copy.deepcopy(X)
+            
+            #x = numpy.zeros(size_x)
+            #y = numpy.zeros(size_y)
+            #X, Y = pylab.meshgrid(x, y)
+            #Z = copy.deepcopy(X)
+            #E = copy.deepcopy(X)
             itot = 0
             i_x = 0
@@ -125,4 +153,8 @@
                 theta = (i_x-center_x+1)*pixel / distance / 100.0
                 qx = 4.0*math.pi/wavelength * math.sin(theta/2.0)
+                
+                if has_converter == True and output.Q_unit != '1/A':
+                    qx = data_conv_q(qx, units=output.Q_unit)
+                
                 x_vals.append(qx)
                 if xmin==None or qx<xmin:
@@ -136,4 +168,8 @@
                 theta = (i_y-center_y+1)*pixel / distance / 100.0
                 qy = 4.0*math.pi/wavelength * math.sin(theta/2.0)
+                
+                if has_converter == True and output.Q_unit != '1/A':
+                    qy = data_conv_q(qy, units=output.Q_unit)
+                
                 y_vals.append(qy)
                 if ymin==None or qy<ymin:
@@ -142,10 +178,12 @@
                     ymax = qy
             
+            # Store the data in the 2D array
             for i_pt in range(len(data)):
-                val = data[i_pt]
                 try:
-                    value = float(val)
+                    value = float(data[i_pt])
                 except:
-                    continue
+                    # For version 1.0, the data were still
+                    # stored as strings at this point.
+                    logging.info("Skipping entry (v1.0):%s,%s" %(str(data[i_pt]), sys.exc_value))
                 
                 # Get bin number
@@ -156,32 +194,63 @@
                     i_x += 1
                     
-                Z[size_y-1-i_y][i_x] = value
+                output.data[size_y-1-i_y][i_x] = value
                 if fversion>1.0:
-                    E[size_y-1-i_y][i_x] = error[i_pt]
+                    output.err_data[size_y-1-i_y][i_x] = error[i_pt]
                 
                 itot += 1
-            from readInfo import ReaderInfo   
-            output = ReaderInfo()
-            output.wavelength = wavelength
-            output.xbins      = size_x
-            output.ybins      = size_y
-            output.center_x   = center_x
-            output.center_y   = center_y
-            # Store the distance in [mm]
-            output.distance   = distance*1000.0
-            output.x_vals     = x_vals
-            output.y_vals     = y_vals
-            output.xmin       = xmin
-            output.xmax       = xmax
-            output.ymin       = ymin
-            output.ymax       = ymax
-            output.pixel_size = pixel
-            output.image      = Z
-            output.x          = x_vals
-            output.y          = y_vals
-            output.type       = "2D "
+                
+            # Store all data ######################################
+            # Store wavelength
+            if has_converter==True and output.source.wavelength_unit != 'A':
+                conv = Converter('A')
+                wavelength = conv(wavelength, units=output.source.wavelength_unit)
+            output.source.wavelength = wavelength
+                
+            # Store distance
+            if has_converter==True and detector.distance_unit != 'm':
+                conv = Converter('m')
+                distance = conv(distance, units=detector.distance_unit)
+            detector.distance = distance
+            
+            # Store pixel size
+            if has_converter==True and detector.pixel_size_unit != 'mm':
+                conv = Converter('mm')
+                pixel = conv(pixel, units=detector.pixel_size_unit)
+            detector.pixel_size.x = pixel
+            detector.pixel_size.y = pixel
+
+            # Store beam center in distance units
+            detector.beam_center.x = center_x*pixel
+            detector.beam_center.y = center_y*pixel
+            
+            # Store limits of the image (2D array)
+            if has_converter == True and output.Q_unit != '1/A':
+                xmin = data_conv_q(xmin, units=output.Q_unit)
+                xmax = data_conv_q(xmax, units=output.Q_unit)
+                ymin = data_conv_q(ymin, units=output.Q_unit)
+                ymax = data_conv_q(ymax, units=output.Q_unit)
+            output.xmin = xmin
+            output.xmax = xmax
+            output.ymin = ymin
+            output.ymax = ymax
+            
+            # Store x and y axis bin centers
+            output.x_bins     = x_vals
+            output.y_bins     = y_vals
+           
+            # Units
+            if data_conv_q is not None:
+                output.xaxis("\\rm{Q}", output.Q_unit)
+                output.yaxis("\\rm{Q}", output.Q_unit)
+            else:
+                output.xaxis("\\rm{Q}", 'A^{-1}')
+                output.yaxis("\\rm{Q}", 'A^{-1}')
+                
+            if data_conv_i is not None:
+                output.zaxis("\\{I(Q)}", output.I_unit)
+            else:
+                output.zaxis("\\rm{I(Q)}","cm^{-1}")
            
             if not fversion>=1.0:
-                #output.error  = E
                 raise ValueError,"Danse_reader can't read this file %s"%filename
             else:
@@ -190,2 +259,7 @@
         
         return None
+
+if __name__ == "__main__": 
+    reader = Reader()
+    print reader.read("../test/MP_New.sans")
+    
