Changeset f98961f in sasview for sansrealspace

Timestamp:

Sep 28, 2007 10:48:09 AM (17 years ago)

Author:

Mathieu Doucet <doucetm@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

3c75696

Parents:

1b0707e1

Message:

Updated run() and runXY() to be compatible with the rest of the models

Location:

sansrealspace/src/realspace

Files:

• VolumeCanvas.py (modified) (4 diffs)
• test/utest_oriented.py (modified) (1 diff)

sansrealspace/src/realspace/VolumeCanvas.py

@@ -8 +8 @@
 from sansModeling.geoshapespy import geoshapespy
 
-import os.path
+import os.path, math
 
 class ShapeDescriptor:
@@ -23 +23 @@
         self.params = {}
         self.params["center"] = [0, 0, 0]
+        # Orientation are angular offsets in degrees with respect to X, Y, Z
         self.params["orientation"] = [0, 0, 0]
         # Default to lores shape
@@ -72 +73 @@
     """
         Descriptor for a cylinder
+        Orientation: Default cylinder is along Y
     """
     def __init__(self):
@@ -478 +480 @@
         """
             Returns the value of I(q) for a given q-value
-            @param q: q-value [float]
-            @return: I(q) [float]
-        """
-        #TODO: The right simulation function should be
-        # called according to the type of input we get.
-        # For now, only a q length is supported.
-        return getIq(q)
+            @param q: q-value ([float] or [list]) ([A-1] or [[A-1], [rad]])
+            @return: I(q) [float] [cm-1]
+        """
+        # Check for 1D q length
+        if q.__class__.__name__ == 'int' \
+            or q.__class__.__name__ == 'float':
+            return self.getIq(q)
+        # Check for 2D q-value
+        elif q.__class__.__name__ == 'list':
+            # Compute (Qx, Qy) from (Q, phi)
+            # Phi is in radian and Q-values are in A-1
+            qx = q[0]*math.cos(q[1])
+            qy = q[0]*math.sin(q[1])
+            return self.getIq2D(qx, qy)
+        # Through an exception if it's not a
+        # type we recognize
+        else:
+            raise ValueError, "run(q): bad type for q"
+    
+    def runXY(self, q = 0):
+        """
+            Standard run command for the canvas.
+            Redirects to the correct method 
+            according to the input type.
+            @param q: q-value [float] or [list] [A-1]
+            @return: I(q) [float] [cm-1]
+        """
+        # Check for 1D q length
+        if q.__class__.__name__ == 'int' \
+            or q.__class__.__name__ == 'float':
+            return self.getIq(q)
+        # Check for 2D q-value
+        elif q.__class__.__name__ == 'list':
+            return self.getIq2D(q[0], q[1])
+        # Through an exception if it's not a
+        # type we recognize
+        else:
+            raise ValueError, "runXY(q): bad type for q"
+    
+        
+    def getIq2D(self, qx, qy):
+        """
+            Returns simulate I(q) for given q_x and q_y values.
+            @param qx: q_x [A-1]
+            @param qy: q_y [A-1]
+            @return: I(q) [cm-1]
+        """
+        # To find a complete example of the correct call order:
+        # In LORES2, in actionclass.py, method CalculateAction._get_iq()
+        
+        # If there are not shapes, do nothing
+        if len(self.shapes) == 0:
+            self.hasPr = False
+            return 0
+        
+        # generate space filling points from shape list
+        self.createVolumeFromList()
+
+        self.points = pointsmodelpy.new_point3dvec()
+
+        pointsmodelpy.complexmodel_add(self.complex_model, 
+                                        self.lores_model, "LORES")
+        for shape in self.shapes:
+            if self.shapes[shape].params['is_lores'] == False:
+                pointsmodelpy.complexmodel_add(self.complex_model, 
+                    self.shapes[shape].shapeObject, "PDB")
+        
+        #pointsmodelpy.get_lorespoints(self.lores_model, self.points)
+        self.npts = pointsmodelpy.get_complexpoints(self.complex_model, self.points)
+                
+        norm =  1.0e8/self.params['lores_density']*self.params['scale']
+        #return norm*pointsmodelpy.get_lores_i(self.lores_model, q)
+        return norm*pointsmodelpy.get_complex_iq_2D(self.complex_model, self.points, qx, qy)\
+            + self.params['background']
+                
         
     def getIq(self, q):

sansrealspace/src/realspace/test/utest_oriented.py

@@ -254 +254 @@
         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
+class TestRunMethods(unittest.TestCase):
+    """ Tests run methods for oriented (2D) systems """
+
+    def setUp(self):
+        """ Set up ellipsoid """
+        from sans.models.EllipsoidModel import EllipsoidModel
+        
+        radius_a = 10
+        radius_b = 15
+        density = 1
+        
+        self.ana = EllipsoidModel()
+        self.ana.setParam('scale', 1.0)
+        self.ana.setParam('contrast', 1.0)
+        self.ana.setParam('background', 0.0)
+        self.ana.setParam('radius_a', radius_a)
+        self.ana.setParam('radius_b', radius_b)
+
+       
+        canvas = VolumeCanvas.VolumeCanvas()
+        canvas.setParam('lores_density', density)
+        self.handle = canvas.add('ellipsoid')
+        canvas.setParam('%s.radius_x' % self.handle, radius_a)
+        canvas.setParam('%s.radius_y' % self.handle, radius_b)
+        canvas.setParam('%s.radius_z' % self.handle, radius_b)
+        canvas.setParam('scale' , 1.0)
+        canvas.setParam('%s.contrast' % self.handle, 1.0)
+        canvas.setParam('background' , 0.0)
+        self.canvas = canvas     
+           
+        self.ana.setParam('axis_theta', 1.57)
+        self.ana.setParam('axis_phi', 0)
+        
+        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
+        
+
+    def testRunXY_List(self):
+        """ Testing ellipsoid along X """
+        ana_val = self.ana.runXY([0.1, 0.2])
+        sim_val = self.canvas.runXY([0.1, 0.2])
+        #print ana_val, sim_val, sim_val/ana_val
+        
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+
+    def testRunXY_float(self):
+        """ Testing ellipsoid along X """
+        ana_val = self.ana.runXY(0.1)
+        sim_val = self.canvas.runXY(0.1)
+        #print ana_val, sim_val, sim_val/ana_val
+        
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+
+    def testRun_float(self):
+        """ Testing ellipsoid along X """
+        ana_val = self.ana.run(0.1)
+        sim_val = self.canvas.run(0.1)
+        #print ana_val, sim_val, sim_val/ana_val
+        
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+
+    def testRun_list(self):
+        """ Testing ellipsoid along X """
+        ana_val = self.ana.run([0.1, 33.0])
+        sim_val = self.canvas.run([0.1, 33.0])
+        #print ana_val, sim_val, sim_val/ana_val
+        
+        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+
+          
+
+
 if __name__ == '__main__':
     unittest.main()