Index: sansmodels/src/sans/models/test/utest_other_models.py
===================================================================
--- sansmodels/src/sans/models/test/utest_other_models.py	(revision 7ef319e68ef906f6b1d16766cf30679154c648cf)
+++ sansmodels/src/sans/models/test/utest_other_models.py	(revision 64f0c5d6c6985750c078b0ca53a736b77b49d2a9)
@@ -22,4 +22,5 @@
             - hardSphereStructure
             
+    @ Note: We don't use matrix for 2D anymore so testEval2D can be ignored (JC)     
             
 """
@@ -48,7 +49,8 @@
         self.x_array = self.comp.evalDistribution(self.x)
         self.y_array = self.comp.evalDistribution(self.y)
-        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
-        qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        
+        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
+        qy_prime = numpy.reshape(self.y, [len(self.y),1])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -67,12 +69,11 @@
     def testEval_2D(self):
         """ Test 2D model for a coreshell  with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-        
-    def testCriticalPoint(self):
-        """ Test coreshell at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point    
+    #def testCriticalPoint(self):
+    #    """ Test coreshell at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
   
 class TestMultiShellModel(unittest.TestCase):
@@ -98,5 +99,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -115,12 +116,11 @@
     def testEval_2D(self):
         """ Test 2D model for a MultiShell  with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-    
-    def testCriticalPoint(self):
-        """ Test multishell at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test multishell at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
     
 class TestVesicleModel(unittest.TestCase):
@@ -142,7 +142,7 @@
         self.x_array = self.comp.evalDistribution(self.x)
         self.y_array = self.comp.evalDistribution(self.y)
-        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
-        qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        #qx_prime = numpy.reshape(self.x, [1,len(self.x)])
+        #qy_prime = numpy.reshape(self.y, [len(self.y),1])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -161,8 +161,7 @@
     def testEval_2D(self):
         """ Test 2D model for a Vesicle with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -191,7 +190,7 @@
         self.x_array = self.comp.evalDistribution(self.x)
         self.y_array = self.comp.evalDistribution(self.y)
-        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
-        qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        #qx_prime = numpy.reshape(self.x, [1,len(self.x)])
+        #qy_prime = numpy.reshape(self.y, [len(self.y),1])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -210,12 +209,11 @@
     def testEval_2D(self):
         """ Test 2D model for a BinaryHS with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-        
-    def testCriticalPoint(self):
-        """ Test BinaryHS at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point    
+    #def testCriticalPoint(self):
+    #    """ Test BinaryHS at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
        
      
@@ -243,5 +241,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -266,12 +264,11 @@
     def testEval_2D(self):
         """ Test 2D model for a CoreShellCylinder with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
- 
-    def testCriticalPoint(self):
-        """ Test CoreShellCylinder at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test CoreShellCylinder at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
  
  
@@ -287,5 +284,6 @@
         self.comp.setParam("radius",30)
         self.comp.setParam("length", 400)
-        self.comp.setParam("contrast",5.3e-6 )
+        self.comp.setParam("sldCyl",6.3e-6 )
+        self.comp.setParam("sldSolv",1e-6 )
         self.comp.setParam("Background", 0.01)
         
@@ -296,5 +294,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -319,12 +317,11 @@
     def testEval_2D(self):
         """ Test 2D model for a HollowCylinder with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-        
-    def testCriticalPoint(self):
-        """ Test HollowCylinder at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point    
+    #def testCriticalPoint(self):
+    #    """ Test HollowCylinder at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
         
         
@@ -337,5 +334,6 @@
         #Give initial value to model
         self.comp.setParam("scale", 1.0)
-        self.comp.setParam("contrast",5.3e-6 )
+        self.comp.setParam("sldSolv",6.3e-6 )
+        self.comp.setParam("sldCyl",1e-6 )
         self.comp.setParam("kuhn_length",100)
         self.comp.setParam("length", 1000)
@@ -350,5 +348,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -372,12 +370,11 @@
     def testEval_2D(self):
         """ Test 2D model for a FlexibleCylinder Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-   
-    def testCriticalPoint(self):
-        """ Test FlexibleCylinder at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test FlexibleCylinder at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
   
               
@@ -409,5 +406,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -432,12 +429,11 @@
     def testEval_2D(self):
         """ Test 2D model for a StackedDisks Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-    
-    def testCriticalPoint(self):
-        """ Test StackedDisks at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0))) 
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test StackedDisks at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0))) 
    
   
@@ -453,5 +449,6 @@
         self.comp.setParam("short_b", 75)
         self.comp.setParam("long_c",400 )
-        self.comp.setParam("contrast", 5.3e-006 )
+        self.comp.setParam("sldPipe", 6.3e-006 )
+        self.comp.setParam("sldSolv", 1e-006 )
         self.comp.setParam("scale",1.0 )
         
@@ -463,5 +460,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -487,8 +484,7 @@
     def testEval_2D(self):
         """ Test 2D model for a Parallelepiped Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
    
     def testCriticalPoint(self):
@@ -506,5 +502,6 @@
         self.comp.setParam("r_ratio",1.5) 
         self.comp.setParam("length",400.0)
-        self.comp.setParam("contrast",5.3e-006)
+        self.comp.setParam("sldCyl",4e-006)
+        self.comp.setParam("sldSolv",1e-006)
         self.comp.setParam("background",0.0)
         self.comp.setParam("cyl_theta",0.0)
@@ -519,5 +516,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -528,5 +525,5 @@
     def test1D(self):
         """ Test 1D model for a EllipticalCylinder Model"""
-        self.assertAlmostEqual(self.comp.run(0.001),2108.32, 1)
+        self.assertAlmostEqual(self.comp.run(0.001), 675.504402, 4)
         
     def test1D_2(self):
@@ -542,8 +539,7 @@
     def testEval_2D(self):
         """ Test 2D model for a EllipticalCylinder with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -561,5 +557,6 @@
         self.comp.setParam("radius_a",20.0)
         self.comp.setParam("radius_b",400.0)
-        self.comp.setParam("contrast",3e-006)
+        self.comp.setParam("sldEll",4e-006)
+        self.comp.setParam("sldSolv",1e-006)
         self.comp.setParam("background",0.0)
         self.comp.setParam("axis_theta",1.57)
@@ -573,5 +570,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -595,8 +592,7 @@
     def testEval_2D(self):
         """ Test 2D model for a Ellipsoid Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -616,5 +612,6 @@
         self.comp.setParam("equat_shell",250.0)
         self.comp.setParam("polar_shell", 30.0)
-        self.comp.setParam("contrast",1e-006)
+        self.comp.setParam("sld_shell",1e-006)
+        self.comp.setParam("sld_core",2e-006)
         self.comp.setParam("sld_solvent",6.3e-006)
         self.comp.setParam("background",0.001)
@@ -629,5 +626,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -638,5 +635,5 @@
     def test1D(self):
         """ Test 1D model for a CoreShellEllipsoid Model"""
-        self.assertAlmostEqual(self.comp.run(1.0), 0.002578943, 4)
+        self.assertAlmostEqual(self.comp.run(1.0), 0.001894, 4)
         
     def test1D_2(self):
@@ -652,8 +649,7 @@
     def testEval_2D(self):
         """ Test 2D model for a CoreShellEllipsoid with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -671,5 +667,6 @@
         self.comp.setParam("semi_axisB", 100.0)
         self.comp.setParam("semi_axisC",400.0 )
-        self.comp.setParam("contrast",5.3e-6)
+        self.comp.setParam("sldSolv",6.3e-6)
+        self.comp.setParam("sldEll",1e-6)
         self.comp.setParam("background",0.0)
         self.comp.setParam("axis_theta", 1.0)
@@ -684,5 +681,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         self.q = 0.001
@@ -708,8 +705,7 @@
     def testEval_2D(self):
         """ Test 2D model for a TriaxialEllipsoid Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -736,13 +732,13 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
         """ Test 1D model for a Lamellar Model"""
-        self.assertAlmostEquals(self.comp.run(0.001), 902120)
+        self.assertAlmostEquals(self.comp.run(0.001), 882289.54309, 3)
         
     def test1D_2(self):
         """ Test 2D model for a Lamellar Model"""
-        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),902120)     
+        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),882289.54309, 3)     
     
     def testEval_1D(self):
@@ -753,12 +749,11 @@
     def testEval_2D(self):
         """ Test 2D model for a Lamellar Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)        
-   
-    def testCriticalPoint(self):
-        """ Test Lamellar at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+       
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test Lamellar at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
      
 class TestLamellarFFHGModel(unittest.TestCase):
@@ -783,14 +778,14 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         
     def test1D(self):
         """ Test 1D model for a LamellarFFHG Model"""
-        self.assertAlmostEquals(self.comp.run(0.001),653144)
+        self.assertAlmostEquals(self.comp.run(0.001),653143.9209, 3)
         
     def test1D_2(self):
         """ Test 2D model for a LamellarFFHG Model"""
-        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),653144)
+        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),653143.9209, 3)
     
     def testEval_1D(self):
@@ -801,12 +796,11 @@
     def testEval_2D(self):
         """ Test 2D model for a LamellarFFHG Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)        
-    
-    def testCriticalPoint(self):
-        """ Test LamellarFFHG at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))              
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+      
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test LamellarFFHG at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))              
     
 class TestLamellarPSModel(unittest.TestCase):
@@ -819,5 +813,6 @@
         self.comp.setParam("spacing",400.0)
         self.comp.setParam("delta",30.0)
-        self.comp.setParam("contrast",5.3e-006)
+        self.comp.setParam("sld_bi",6.3e-006)
+        self.comp.setParam("sld_sol",1e-006)
         self.comp.setParam("n_plates",20.0) 
         self.comp.setParam("caille", 0.1)
@@ -831,14 +826,14 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         
     def test1D(self):
         """ Test 1D model for a LamellarPS Model"""
-        self.assertAlmostEquals(self.comp.run(0.001), 28526.8, 1)
+        self.assertAlmostEquals(self.comp.run(0.001), 27899.30836, 1)
         
     def test1D_2(self):
         """ Test 2D model for a LamellarPS Model"""
-        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),28526.8, 1) 
+        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),27899.30836, 1) 
     
     def testEval_1D(self):
@@ -849,12 +844,11 @@
     def testEval_2D(self):
         """ Test 2D model for a LamellarPS Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)        
-            
-    def testCriticalPoint(self):
-        """ Test LamellarPS at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+      
+    # No more singular point        
+    #def testCriticalPoint(self):
+    #    """ Test LamellarPS at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
      
 class TestLamellarPSHGModel(unittest.TestCase):
@@ -882,13 +876,13 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
         """ Test 1D model for a LamellarPSHG Model"""
-        self.assertAlmostEquals(self.comp.run(0.001),6.83139e6, 3)
+        self.assertAlmostEquals(self.comp.run(0.001),6831387.29466, 3)
         
     def test1D_2(self):
         """ Test 2D model for a LamellarPSHG Model"""
-        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),6.83139e6,3)
+        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),6831387.29466,3)
         
     def testEval_1D(self):
@@ -899,12 +893,11 @@
     def testEval_2D(self):
         """ Test 2D model for a LamellarPSHG Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)        
-    
-    def testCriticalPoint(self):
-        """ Test LamellarPSHG at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+       
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test LamellarPSHG at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
      
 class TestSquareWellStructure(unittest.TestCase):
@@ -926,5 +919,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         
@@ -944,12 +937,11 @@
     def testEval_2D(self):
         """ Test 2D model for a SquareWellStructure with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-    
-    def testCriticalPoint(self):
-        """ Test SquareWellStructure at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))                     
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test SquareWellStructure at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))                     
      
 class TestHardsphereStructure(unittest.TestCase):
@@ -968,5 +960,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
         
@@ -986,12 +978,11 @@
     def testEval_2D(self):
         """ Test 2D model for a HardsphereStructure with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-    
-    def testCriticalPoint(self):
-        """ Test HardsphereStructure at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))                  
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test HardsphereStructure at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))                  
     
 class TestStickyHSStructure(unittest.TestCase):
@@ -1013,5 +1004,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1030,12 +1021,11 @@
     def testEval_2D(self):
         """ Test 2D model for a StickyHSStructure with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-               
-    def testCriticalPoint(self):
-        """ Test StickyHSStructure at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0))) 
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point           
+    #def testCriticalPoint(self):
+    #    """ Test StickyHSStructure at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0))) 
         
 class TestHayterMSAStructure(unittest.TestCase):
@@ -1059,5 +1049,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
 
     def test1D(self):
@@ -1076,8 +1066,7 @@
     def testEval_2D(self):
         """ Test 2D model for a HayterMSAStructure with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1109,6 +1098,6 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
-        
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
+
     def test1D(self):
         """ Test 1D model for a BEPolyelectrolyte"""
@@ -1126,8 +1115,7 @@
     def testEval_2D(self):
         """ Test 2D model for a BEPolyelectrolyte with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
    
     def testCriticalPoint(self):
@@ -1153,13 +1141,13 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
         """ Test 1D model for a DABModel"""
-        self.assertAlmostEqual(self.comp.run(0.001),10.9681, 3)
+        self.assertAlmostEqual(self.comp.run(0.001),637957.9047, 3)
         
     def test1D_2(self):
         """ Test 2D model for a DABModel"""
-        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),10.9681, 3)
+        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),637957.90473, 3)
          
     def testEval_1D(self):
@@ -1170,8 +1158,7 @@
     def testEval_2D(self):
         """ Test 2D model for a DABModel with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1196,5 +1183,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1213,8 +1200,7 @@
     def testEval_2D(self):
         """ Test 2D model for a GuinierModel with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1240,5 +1226,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1257,8 +1243,7 @@
     def testEval_2D(self):
         """ Test 2D model for a DebyeModel with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1283,5 +1268,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1300,8 +1285,7 @@
     def testEval_2D(self):
         """ Test 2D model for a PorodModel with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCreaticalPoint(self):
@@ -1328,5 +1312,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1345,8 +1329,6 @@
     def testEval_2D(self):
         """ Test 2D model for a PeakGauss Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
     
     def testCriticalPoint(self):
@@ -1372,5 +1354,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1389,8 +1371,7 @@
     def testEval_2D(self):
         """ Test 2D model for a PeakLorentz Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
         
     def testCriticalPoint(self):
@@ -1398,5 +1379,5 @@
         self.comp.setParam('B', 0.0)
         self.assertRaises(ZeroDivisionError, self.comp.run, 10)
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))  
+        #self.assert_(numpy.isfinite(self.comp.run(0.0)))  
         
        
@@ -1410,7 +1391,7 @@
         self.comp.setParam('radius', 5.0)
         self.comp.setParam('fractal_dim', 2.0)
-        self.comp.setParam('corr_length',100.0)
-        self.comp.setParam('block_sld', 2.0e-6)
-        self.comp.setParam('solvent_sld', 6.35e-6)
+        self.comp.setParam('cor_length',100.0)
+        self.comp.setParam('sldBlock', 2.0e-6)
+        self.comp.setParam('sldSolv', 6.35e-6)
         self.comp.setParam('background',0.0)
         
@@ -1422,5 +1403,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1439,12 +1420,11 @@
     def testEval_2D(self):
         """ Test 2D model for a Fractal Abs Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-    
-    def testCriticalPoint(self):
-        """ Test Fractal Abs at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))    
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point
+    #def testCriticalPoint(self):
+    #    """ Test Fractal Abs at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))    
    
 class TestFractalModel(unittest.TestCase):
@@ -1457,7 +1437,7 @@
         self.comp.setParam('radius', 5.0)
         self.comp.setParam('fractal_dim', 2.0)
-        self.comp.setParam('corr_length',100.0)
-        self.comp.setParam('block_sld', 2.0e-6)
-        self.comp.setParam('solvent_sld', 6.35e-6)
+        self.comp.setParam('cor_length',100.0)
+        self.comp.setParam('sldBlock', 2.0e-6)
+        self.comp.setParam('sldSolv', 6.35e-6)
         self.comp.setParam('background',0.0)
         
@@ -1469,5 +1449,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1486,12 +1466,11 @@
     def testEval_2D(self):
         """ Test 2D model for a Fractal Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
-        
-    def testCriticalPoint(self):
-        """ Test Fractal at the critical point"""
-        self.assert_(numpy.isfinite(self.comp.run(0.0)))
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
+    # No more singular point    
+    #def testCriticalPoint(self):
+    #    """ Test Fractal at the critical point"""
+    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
     
 class TestLorentzModel(unittest.TestCase):
@@ -1512,5 +1491,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1529,8 +1508,7 @@
     def testEval_2D(self):
         """ Test 2D model for a Lorentz Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
           
     def testCriticalPoint(self):
@@ -1555,5 +1533,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1572,8 +1550,7 @@
     def testEval_2D(self):
         """ Test 2D model for a PowerLawAbs Model with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1598,5 +1575,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1615,8 +1592,7 @@
     def testEval_2D(self):
         """ Test 2D model for a PowerLawModel with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1642,5 +1618,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1659,8 +1635,7 @@
     def testEval_2D(self):
         """ Test 2D model for a TeubnerStrey  with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
@@ -1684,5 +1659,5 @@
         qx_prime = numpy.reshape(self.x, [1,len(self.x)])
         qy_prime = numpy.reshape(self.y, [len(self.y),1])
-        self.xy_matrix = self.comp.evalDistribution([qx_prime, qy_prime])
+        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
         
     def test1D(self):
@@ -1697,8 +1672,7 @@
     def testEval_2D(self):
         """ Test 2D model for a Line  with evalDistribution"""
-        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0][0],8)
-        self.assertAlmostEquals(self.comp.runXY([0.4,1.57]),self.xy_matrix[1][0], 8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 0.5]),self.xy_matrix[0][1],8)
-        self.assertAlmostEquals(self.comp.runXY([1.3, 1.57]),self.xy_matrix[1][1],8)
+        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0], 8)
+        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
+
     
     def testCriticalPoint(self):
