Changeset 1cdbcd8 in sasview


Ignore:
Timestamp:
Sep 23, 2017 1:06:57 PM (13 months ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_Pr, ESS_GUI_Pr_fixes, ESS_GUI_corf, ESS_GUI_image_viewer, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_project_save, SVCC-1, SasView-664, gpu-options-handling, py37-all, py37-sascalc, py37-sasgui, pytest, simplify-c-build, ticket-1094-headless, ticket-1111, ticket-818, ticket885, unittest-saveload, win64bit_conda_vm
Children:
aaa801e
Parents:
f00072f
Message:

move tests to use sasmodels rather than sas.models (tests will still fail)

Location:
test/sasrealspace/test
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • test/sasrealspace/test/utest_oriented.py

    raaf5e49 r1cdbcd8  
    99# Disable "missing docstring" complaint 
    1010# pylint: disable-msg=C0111 
    11 # Disable "too many methods" complaint  
    12 # pylint: disable-msg=R0904  
    13 # Disable "could be a function" complaint  
     11# Disable "too many methods" complaint 
     12# pylint: disable-msg=R0904 
     13# Disable "could be a function" complaint 
    1414# pylint: disable-msg=R0201 
    1515# pylint: disable-msg=W0702 
    1616 
    17 try: 
    18     import VolumeCanvas 
    19     print("Testing local version") 
    20 except: 
    21     print(sys.exc_value) 
    22     #testing the version that is working on 
    23     print("Testing installed version") 
    24     import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    25   
     17from sasmodels.sasview_model import _make_standard_model 
     18EllipsoidModel = _make_standard_model('ellipsoid') 
     19SphereModel = _make_standard_model('sphere') 
     20CylinderModel = _make_standard_model('cylinder') 
     21CoreShellModel = _make_standard_model('core_shell_sphere') 
     22 
     23import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
     24 
     25 
    2626 
    2727class TestSphere(unittest.TestCase): 
    2828    """ Tests for oriented (2D) systems """ 
    29          
     29 
    3030    def setUp(self): 
    3131        """ 
    3232            Set up canvas 
    3333        """ 
    34         from sas.models.SphereModel import SphereModel 
    3534        self.model = VolumeCanvas.VolumeCanvas() 
    36      
     35 
    3736        handle = self.model.add('sphere') 
    38          
     37 
    3938        radius = 10 
    4039        density = .1 
    41          
     40 
    4241        ana = SphereModel() 
    4342        ana.setParam('scale', 1.0) 
    44         ana.setParam('contrast', 1.0) 
    4543        ana.setParam('background', 0.0) 
     44        ana.setParam('sld', 1.0) 
     45        ana.setParam('sld_solvent', 0.0) 
    4646        ana.setParam('radius', radius) 
    4747        self.ana = ana 
    48          
     48 
    4949        self.model.setParam('lores_density', density) 
     50        self.model.setParam('scale' , 1.0) 
     51        self.model.setParam('background' , 0.0) 
     52        self.model.setParam('%s.contrast' % handle, 1.0) 
    5053        self.model.setParam('%s.radius' % handle, radius) 
    51         self.model.setParam('scale' , 1.0) 
    52         self.model.setParam('%s.contrast' % handle, 1.0) 
    53         self.model.setParam('background' , 0.0) 
    54          
    55          
     54 
     55 
    5656    def testdefault(self): 
    5757        """ Testing sphere """ 
     
    6060        sim_val = self.model.getIq2D(0.1, 0.1) 
    6161        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 ) 
    62          
     62 
    6363class TestCylinderAddObject(unittest.TestCase): 
    6464    """ Tests for oriented (2D) systems """ 
    65          
     65 
    6666    def setUp(self): 
    6767        """ Set up cylinder model """ 
    68         from sas.models.CylinderModel import CylinderModel 
    6968        radius = 5 
    7069        length = 40 
    7170        density = 20 
    72      
     71 
    7372        # Analytical model 
    7473        self.ana = CylinderModel() 
    7574        self.ana.setParam('scale', 1.0) 
    76         self.ana.setParam('contrast', 1.0) 
    7775        self.ana.setParam('background', 0.0) 
     76        self.ana.setParam('sld', 1.0) 
     77        self.ana.setParam('sld_solvent', 0.0) 
    7878        self.ana.setParam('radius', radius) 
    7979        self.ana.setParam('length', length) 
    80      
     80 
    8181        # Simulation model 
    8282        self.model = VolumeCanvas.VolumeCanvas() 
     
    8484        self.handle = self.model.addObject(cyl) 
    8585        self.model.setParam('lores_density', density) 
     86        self.model.setParam('scale' , 1.0) 
     87        self.model.setParam('background' , 0.0) 
     88        self.model.setParam('%s.contrast' % self.handle, 1.0) 
    8689        self.model.setParam('%s.radius' % self.handle, radius) 
    8790        self.model.setParam('%s.length' % self.handle, length) 
    88         self.model.setParam('scale' , 1.0) 
    89         self.model.setParam('%s.contrast' % self.handle, 1.0) 
    90         self.model.setParam('background' , 0.0) 
    91      
     91 
    9292    def testalongY(self): 
    9393        """ Testing cylinder along Y axis """ 
    94         self.ana.setParam('cyl_theta', math.pi/2.0) 
    95         self.ana.setParam('cyl_phi', math.pi/2.0) 
    96          
     94        self.ana.setParam('theta', math.pi/2.0) 
     95        self.ana.setParam('phi', math.pi/2.0) 
     96 
    9797        self.model.setParam('%s.orientation' % self.handle, [0,0,0]) 
    98          
    99         ana_val = self.ana.runXY([0.1, 0.2]) 
    100         sim_val = self.model.getIq2D(0.1, 0.2) 
    101         #print ana_val, sim_val, sim_val/ana_val 
    102          
    103         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    104          
    105          
     98 
     99        ana_val = self.ana.runXY([0.1, 0.2]) 
     100        sim_val = self.model.getIq2D(0.1, 0.2) 
     101        #print ana_val, sim_val, sim_val/ana_val 
     102 
     103        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     104 
     105 
    106106class TestCylinder(unittest.TestCase): 
    107107    """ Tests for oriented (2D) systems """ 
    108          
     108 
    109109    def setUp(self): 
    110110        """ Set up cylinder model """ 
    111         from sas.models.CylinderModel import CylinderModel 
    112111        radius = 5 
    113112        length = 40 
    114113        density = 20 
    115      
     114 
    116115        # Analytical model 
    117116        self.ana = CylinderModel() 
    118117        self.ana.setParam('scale', 1.0) 
    119         self.ana.setParam('contrast', 1.0) 
    120118        self.ana.setParam('background', 0.0) 
     119        self.ana.setParam('sld', 1.0) 
     120        self.ana.setParam('sld_solvent', 0.0) 
    121121        self.ana.setParam('radius', radius) 
    122122        self.ana.setParam('length', length) 
    123      
     123 
    124124        # Simulation model 
    125125        self.model = VolumeCanvas.VolumeCanvas() 
    126126        self.handle = self.model.add('cylinder') 
    127127        self.model.setParam('lores_density', density) 
     128        self.model.setParam('scale' , 1.0) 
     129        self.model.setParam('background' , 0.0) 
    128130        self.model.setParam('%s.radius' % self.handle, radius) 
    129131        self.model.setParam('%s.length' % self.handle, length) 
    130         self.model.setParam('scale' , 1.0) 
    131132        self.model.setParam('%s.contrast' % self.handle, 1.0) 
    132         self.model.setParam('background' , 0.0) 
    133      
     133 
    134134    def testalongY(self): 
    135135        """ Testing cylinder along Y axis """ 
    136         self.ana.setParam('cyl_theta', math.pi/2.0) 
    137         self.ana.setParam('cyl_phi', math.pi/2.0) 
    138          
     136        self.ana.setParam('theta', math.pi/2.0) 
     137        self.ana.setParam('phi', math.pi/2.0) 
     138 
    139139        self.model.setParam('%s.orientation' % self.handle, [0,0,0]) 
    140          
    141         ana_val = self.ana.runXY([0.1, 0.2]) 
    142         sim_val = self.model.getIq2D(0.1, 0.2) 
    143         #print ana_val, sim_val, sim_val/ana_val 
    144          
    145         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    146          
     140 
     141        ana_val = self.ana.runXY([0.1, 0.2]) 
     142        sim_val = self.model.getIq2D(0.1, 0.2) 
     143        #print ana_val, sim_val, sim_val/ana_val 
     144 
     145        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     146 
    147147    def testalongZ(self): 
    148148        """ Testing cylinder along Z axis """ 
    149         self.ana.setParam('cyl_theta', 0) 
    150         self.ana.setParam('cyl_phi', 0) 
    151          
     149        self.ana.setParam('theta', 0) 
     150        self.ana.setParam('phi', 0) 
     151 
    152152        self.model.setParam('%s.orientation' % self.handle, [90,0,0]) 
    153          
    154         ana_val = self.ana.runXY([0.1, 0.2]) 
    155         sim_val = self.model.getIq2D(0.1, 0.2) 
    156         #print ana_val, sim_val, sim_val/ana_val 
    157          
    158         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    159          
     153 
     154        ana_val = self.ana.runXY([0.1, 0.2]) 
     155        sim_val = self.model.getIq2D(0.1, 0.2) 
     156        #print ana_val, sim_val, sim_val/ana_val 
     157 
     158        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     159 
    160160    def testalongX(self): 
    161161        """ Testing cylinder along X axis """ 
    162         self.ana.setParam('cyl_theta', 1.57) 
    163         self.ana.setParam('cyl_phi', 0) 
    164          
     162        self.ana.setParam('theta', 1.57) 
     163        self.ana.setParam('phi', 0) 
     164 
    165165        self.model.setParam('%s.orientation' % self.handle, [0,0,90]) 
    166          
    167         ana_val = self.ana.runXY([0.1, 0.2]) 
    168         sim_val = self.model.getIq2D(0.1, 0.2) 
    169         #print ana_val, sim_val, sim_val/ana_val 
    170          
    171         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    172          
     166 
     167        ana_val = self.ana.runXY([0.1, 0.2]) 
     168        sim_val = self.model.getIq2D(0.1, 0.2) 
     169        #print ana_val, sim_val, sim_val/ana_val 
     170 
     171        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     172 
    173173class TestEllipsoid(unittest.TestCase): 
    174174    """ Tests for oriented (2D) systems """ 
    175          
     175 
    176176    def setUp(self): 
    177177        """ Set up ellipsoid """ 
    178         from sas.models.EllipsoidModel import EllipsoidModel 
    179          
     178 
    180179        radius_a = 60 
    181180        radius_b = 10 
    182181        density = 30 
    183          
     182 
    184183        self.ana = EllipsoidModel() 
    185184        self.ana.setParam('scale', 1.0) 
    186         self.ana.setParam('contrast', 1.0) 
    187185        self.ana.setParam('background', 0.0) 
    188         self.ana.setParam('radius_a', radius_a) 
    189         self.ana.setParam('radius_b', radius_b) 
     186        self.ana.setParam('sld', 1.0) 
     187        self.ana.setParam('sld_solvent', 0.0) 
     188        self.ana.setParam('radius_polar', radius_a) 
     189        self.ana.setParam('radius_equatorial', radius_b) 
    190190        # Default orientation is there=1.57, phi=0 
    191191        # Radius_a is along the x direction 
    192         
     192 
    193193        canvas = VolumeCanvas.VolumeCanvas() 
     194        self.handle = canvas.add('ellipsoid') 
    194195        canvas.setParam('lores_density', density) 
    195         self.handle = canvas.add('ellipsoid') 
     196        canvas.setParam('scale' , 1.0) 
     197        canvas.setParam('background' , 0.0) 
    196198        canvas.setParam('%s.radius_x' % self.handle, radius_a) 
    197199        canvas.setParam('%s.radius_y' % self.handle, radius_b) 
    198200        canvas.setParam('%s.radius_z' % self.handle, radius_b) 
    199         canvas.setParam('scale' , 1.0) 
    200201        canvas.setParam('%s.contrast' % self.handle, 1.0) 
    201         canvas.setParam('background' , 0.0) 
    202         self.canvas = canvas         
     202        self.canvas = canvas 
    203203 
    204204    def testalongX(self): 
    205205        """ Testing ellipsoid along X """ 
    206         self.ana.setParam('axis_theta', 1.57) 
    207         self.ana.setParam('axis_phi', 0) 
    208          
     206        self.ana.setParam('theta', 1.57) 
     207        self.ana.setParam('phi', 0) 
     208 
    209209        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0]) 
    210          
     210 
    211211        ana_val = self.ana.runXY([0.1, 0.2]) 
    212212        sim_val = self.canvas.getIq2D(0.1, 0.2) 
    213213        #print ana_val, sim_val, sim_val/ana_val 
    214          
     214 
    215215        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    216216 
    217217    def testalongZ(self): 
    218218        """ Testing ellipsoid along Z """ 
    219         self.ana.setParam('axis_theta', 0) 
    220         self.ana.setParam('axis_phi', 0) 
    221          
     219        self.ana.setParam('theta', 0) 
     220        self.ana.setParam('phi', 0) 
     221 
    222222        self.canvas.setParam('%s.orientation' % self.handle, [0,90,0]) 
    223          
     223 
    224224        ana_val = self.ana.runXY([0.1, 0.2]) 
    225225        sim_val = self.canvas.getIq2D(0.1, 0.2) 
    226226        #print ana_val, sim_val, sim_val/ana_val 
    227          
     227 
    228228        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    229229 
    230230    def testalongY(self): 
    231231        """ Testing ellipsoid along Y """ 
    232         self.ana.setParam('axis_theta', math.pi/2.0) 
    233         self.ana.setParam('axis_phi', math.pi/2.0) 
    234          
     232        self.ana.setParam('theta', math.pi/2.0) 
     233        self.ana.setParam('phi', math.pi/2.0) 
     234 
    235235        self.canvas.setParam('%s.orientation' % self.handle, [0,0,90]) 
    236          
     236 
    237237        ana_val = self.ana.runXY([0.05, 0.15]) 
    238238        sim_val = self.canvas.getIq2D(0.05, 0.15) 
    239239        #print ana_val, sim_val, sim_val/ana_val 
    240          
     240 
    241241        try: 
    242242            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    243         except: 
     243        except Exception: 
    244244            print("Error", ana_val, sim_val, sim_val/ana_val) 
    245             raise sys.exc_type, sys.exc_value 
     245            raise 
    246246 
    247247class TestCoreShell(unittest.TestCase): 
    248248    """ Tests for oriented (2D) systems """ 
    249          
     249 
    250250    def setUp(self): 
    251251        """ Set up zero-SLD-average core-shell model """ 
    252         from sas.models.CoreShellModel import CoreShellModel 
    253          
     252 
    254253        radius = 15 
    255254        thickness = 5 
    256255        density = 20 
    257          
     256 
    258257        core_vol = 4.0/3.0*math.pi*radius*radius*radius 
    259258        self.outer_radius = radius+thickness 
     
    262261 
    263262        self.density = density 
    264             
     263 
    265264        # Core-shell 
    266265        sphere = CoreShellModel() 
     266        sphere.setParam('scale', 1.0) 
     267        sphere.setParam('background', 0.0) 
    267268        # Core radius 
    268269        sphere.setParam('radius', radius) 
    269270        # Shell thickness 
    270271        sphere.setParam('thickness', thickness) 
    271         sphere.setParam('core_sld', 1.0) 
    272         sphere.setParam('shell_sld', self.shell_sld) 
    273         sphere.setParam('solvent_sld', 0.0) 
    274         sphere.setParam('background', 0.0) 
    275         sphere.setParam('scale', 1.0) 
     272        sphere.setParam('sld_core', 1.0) 
     273        sphere.setParam('sld_shell', self.shell_sld) 
     274        sphere.setParam('sld_solvent', 0.0) 
    276275        self.ana = sphere 
    277         
    278         canvas = VolumeCanvas.VolumeCanvas()         
     276 
     277        canvas = VolumeCanvas.VolumeCanvas() 
    279278        canvas.setParam('lores_density', self.density) 
    280          
     279        canvas.setParam('scale' , 1.0) 
     280        canvas.setParam('background' , 0.0) 
     281 
    281282        handle = canvas.add('sphere') 
    282283        canvas.setParam('%s.radius' % handle, self.outer_radius) 
    283284        canvas.setParam('%s.contrast' % handle, self.shell_sld) 
    284         
     285 
    285286        handle2 = canvas.add('sphere') 
    286287        canvas.setParam('%s.radius' % handle2, radius) 
    287288        canvas.setParam('%s.contrast' % handle2, 1.0) 
    288                 
    289         canvas.setParam('scale' , 1.0) 
    290         canvas.setParam('background' , 0.0) 
    291         self.canvas = canvas  
    292             
     289 
     290        self.canvas = canvas 
     291 
    293292    def testdefault(self): 
    294293        """ Testing default core-shell orientation """ 
    295294        ana_val = self.ana.runXY([0.1, 0.2]) 
    296295        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    297          
    298         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    299                     
     296 
     297        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     298 
    300299class TestCoreShellError(unittest.TestCase): 
    301300    """ Tests for oriented (2D) systems """ 
    302          
     301 
    303302    def setUp(self): 
    304303        """ Set up zero-SLD-average core-shell model """ 
    305         from sas.models.CoreShellModel import CoreShellModel 
    306          
     304 
    307305        radius = 15 
    308306        thickness = 5 
    309307        density = 5 
    310          
     308 
    311309        core_vol = 4.0/3.0*math.pi*radius*radius*radius 
    312310        self.outer_radius = radius+thickness 
     
    315313 
    316314        self.density = density 
    317             
     315 
    318316        # Core-shell 
    319317        sphere = CoreShellModel() 
     318        sphere.setParam('scale', 1.0) 
     319        sphere.setParam('background', 0.0) 
    320320        # Core radius 
    321321        sphere.setParam('radius', radius) 
    322322        # Shell thickness 
    323323        sphere.setParam('thickness', thickness) 
    324         sphere.setParam('core_sld', 1.0) 
    325         sphere.setParam('shell_sld', self.shell_sld) 
    326         sphere.setParam('solvent_sld', 0.0) 
    327         sphere.setParam('background', 0.0) 
    328         sphere.setParam('scale', 1.0) 
     324        sphere.setParam('sld_core', 1.0) 
     325        sphere.setParam('sld_shell', self.shell_sld) 
     326        sphere.setParam('sld_solvent', 0.0) 
    329327        self.ana = sphere 
    330         
    331         canvas = VolumeCanvas.VolumeCanvas()         
     328 
     329        canvas = VolumeCanvas.VolumeCanvas() 
    332330        canvas.setParam('lores_density', self.density) 
    333          
     331        canvas.setParam('scale' , 1.0) 
     332        canvas.setParam('background' , 0.0) 
     333 
    334334        handle = canvas.add('sphere') 
    335335        canvas.setParam('%s.radius' % handle, self.outer_radius) 
    336336        canvas.setParam('%s.contrast' % handle, self.shell_sld) 
    337         
     337 
    338338        handle2 = canvas.add('sphere') 
    339339        canvas.setParam('%s.radius' % handle2, radius) 
    340340        canvas.setParam('%s.contrast' % handle2, 1.0) 
    341                 
    342         canvas.setParam('scale' , 1.0) 
    343         canvas.setParam('background' , 0.0) 
    344         self.canvas = canvas  
    345                     
     341 
     342        self.canvas = canvas 
     343 
    346344    def testdefault(self): 
    347345        """ Testing default core-shell orientation """ 
    348346        ana_val = self.ana.runXY([0.1, 0.2]) 
    349347        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    350          
     348 
    351349        self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err ) 
    352350 
     
    356354    def setUp(self): 
    357355        """ Set up ellipsoid """ 
    358         from sas.models.EllipsoidModel import EllipsoidModel 
    359          
     356 
    360357        radius_a = 10 
    361358        radius_b = 15 
    362359        density = 5 
    363          
     360 
    364361        self.ana = EllipsoidModel() 
    365362        self.ana.setParam('scale', 1.0) 
    366         self.ana.setParam('contrast', 1.0) 
    367363        self.ana.setParam('background', 0.0) 
    368         self.ana.setParam('radius_a', radius_a) 
    369         self.ana.setParam('radius_b', radius_b) 
    370  
    371         
     364        self.ana.setParam('sld', 1.0) 
     365        self.ana.setParam('sld_solvent', 1.0) 
     366        self.ana.setParam('radius_polar', radius_a) 
     367        self.ana.setParam('radius_equatorial', radius_b) 
     368 
     369 
    372370        canvas = VolumeCanvas.VolumeCanvas() 
     371        self.handle = canvas.add('ellipsoid') 
    373372        canvas.setParam('lores_density', density) 
    374         self.handle = canvas.add('ellipsoid') 
     373        canvas.setParam('scale' , 1.0) 
     374        canvas.setParam('background' , 0.0) 
    375375        canvas.setParam('%s.radius_x' % self.handle, radius_a) 
    376376        canvas.setParam('%s.radius_y' % self.handle, radius_b) 
    377377        canvas.setParam('%s.radius_z' % self.handle, radius_b) 
    378         canvas.setParam('scale' , 1.0) 
    379378        canvas.setParam('%s.contrast' % self.handle, 1.0) 
    380         canvas.setParam('background' , 0.0) 
    381         self.canvas = canvas      
    382             
    383         self.ana.setParam('axis_theta', 1.57) 
    384         self.ana.setParam('axis_phi', 0) 
    385          
     379        self.canvas = canvas 
     380 
     381        self.ana.setParam('theta', 1.57) 
     382        self.ana.setParam('phi', 0) 
     383 
    386384        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0]) 
    387          
     385 
    388386 
    389387    def testRunXY_List(self): 
     
    392390        sim_val = self.canvas.runXY([0.1, 0.2]) 
    393391        #print ana_val, sim_val, sim_val/ana_val 
    394          
     392 
    395393        try: 
    396394            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    397         except: 
     395        except Exception: 
    398396            print("Error", ana_val, sim_val, sim_val/ana_val) 
    399             raise sys.exc_type, sys.exc_value 
     397            raise 
    400398 
    401399    def testRunXY_float(self): 
     
    404402        sim_val = self.canvas.runXY(0.1) 
    405403        #print ana_val, sim_val, sim_val/ana_val 
    406          
     404 
    407405        try: 
    408406            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    409         except: 
     407        except Exception: 
    410408            print("Error", ana_val, sim_val, sim_val/ana_val) 
    411             raise sys.exc_type, sys.exc_value 
     409            raise 
    412410 
    413411    def testRun_float(self): 
     
    416414        sim_val = self.canvas.run(0.1) 
    417415        #print ana_val, sim_val, sim_val/ana_val 
    418          
     416 
    419417        try: 
    420418            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    421         except: 
     419        except Exception: 
    422420            print("Error", ana_val, sim_val, sim_val/ana_val) 
    423             raise sys.exc_type, sys.exc_value 
     421            raise 
    424422 
    425423    def testRun_list(self): 
     
    428426        sim_val = self.canvas.run([0.1, 33.0]) 
    429427        #print ana_val, sim_val, sim_val/ana_val 
    430          
     428 
    431429        try: 
    432430            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    433         except: 
     431        except Exception: 
    434432            print("Error", ana_val, sim_val, sim_val/ana_val) 
    435             raise sys.exc_type, sys.exc_value 
     433            raise 
    436434 
    437435class TestParamChange(unittest.TestCase): 
    438436    """ Tests for oriented (2D) systems """ 
    439          
     437 
    440438    def setUp(self): 
    441439        """ Set up cylinder model """ 
    442         from sas.models.CylinderModel import CylinderModel 
    443440        radius = 5 
    444441        length = 40 
    445442        density = 20 
    446      
     443 
    447444        # Analytical model 
    448445        self.ana = CylinderModel() 
    449446        self.ana.setParam('scale', 1.0) 
    450         self.ana.setParam('contrast', 1.0) 
    451447        self.ana.setParam('background', 0.0) 
     448        self.ana.setParam('sld', 1.0) 
     449        self.ana.setParam('sld_solvent', 0.0) 
    452450        self.ana.setParam('radius', radius) 
    453451        self.ana.setParam('length', length) 
    454         self.ana.setParam('cyl_theta', math.pi/2.0) 
    455         self.ana.setParam('cyl_phi', math.pi/2.0) 
    456      
     452        self.ana.setParam('theta', math.pi/2.0) 
     453        self.ana.setParam('phi', math.pi/2.0) 
     454 
    457455        # Simulation model 
    458456        self.model = VolumeCanvas.VolumeCanvas() 
    459457        self.handle = self.model.add('cylinder') 
    460458        self.model.setParam('lores_density', density) 
     459        self.model.setParam('scale' , 1.0) 
     460        self.model.setParam('background' , 0.0) 
    461461        self.model.setParam('%s.radius' % self.handle, radius) 
    462462        self.model.setParam('%s.length' % self.handle, length) 
    463         self.model.setParam('scale' , 1.0) 
    464463        self.model.setParam('%s.contrast' % self.handle, 1.0) 
    465         self.model.setParam('background' , 0.0) 
    466464        self.model.setParam('%s.orientation' % self.handle, [0,0,0]) 
    467      
     465 
    468466    def testalongY(self): 
    469467        """ Test that a parameter change forces the generation 
     
    472470        ana_val = self.ana.runXY([0.1, 0.2]) 
    473471        sim_val = self.model.getIq2D(0.1, 0.2) 
    474          
    475         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    476          
     472 
     473        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     474 
    477475        # Change the radius a re-evaluate 
    478476        self.ana.setParam('radius', 10) 
    479477        self.model.setParam('%s.radius' % self.handle, 10) 
    480          
     478 
    481479        ana_val = self.ana.runXY([0.1, 0.2]) 
    482480        sim_val = self.model.getIq2D(0.1, 0.2) 
     
    485483 
    486484if __name__ == '__main__': 
    487     unittest.main()         
     485    unittest.main() 
  • test/sasrealspace/test/utest_realspace.py

    raaf5e49 r1cdbcd8  
    99# Disable "missing docstring" complaint 
    1010# pylint: disable-msg=C0111 
    11 # Disable "too many methods" complaint  
    12 # pylint: disable-msg=R0904  
    13 # Disable "could be a function" complaint  
     11# Disable "too many methods" complaint 
     12# pylint: disable-msg=R0904 
     13# Disable "could be a function" complaint 
    1414# pylint: disable-msg=R0201 
    1515 
    16 try: 
    17     import VolumeCanvas 
    18     print("Testing local version") 
    19 except: 
    20     import sys 
    21     print(sys.exc_value) 
    22     #testing the version that is working on 
    23     print("Testing installed version") 
    24     import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    25       
     16from sasmodels.sasview_model import _make_standard_model 
     17EllipsoidModel = _make_standard_model('ellipsoid') 
     18SphereModel = _make_standard_model('sphere') 
     19CylinderModel = _make_standard_model('cylinder') 
     20CoreShellModel = _make_standard_model('core_shell_sphere') 
     21 
     22import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
     23 
    2624class TestRealSpaceModel(unittest.TestCase): 
    2725    """ Unit tests for sphere model """ 
    28      
     26 
    2927    def setUp(self): 
    3028        self.model = VolumeCanvas.VolumeCanvas() 
     
    3331        self.model.add('ellipsoid', 'elli') 
    3432        self.model.add('singlehelix', 'shelix') 
    35          
     33 
    3634    def testAdding(self): 
    37         self.assertEqual('cyl', self.model.add('cylinder', 'cyl'))    
     35        self.assertEqual('cyl', self.model.add('cylinder', 'cyl')) 
    3836 
    3937    def testDeleting(self): 
     
    5553        #print "pr is calculated", self.model.hasPr 
    5654        result = self.model.getIq(0.1) 
    57         #print "I(0.1) is calculated: ", result        
     55        #print "I(0.1) is calculated: ", result 
    5856 
    5957class TestSphere(unittest.TestCase): 
     
    6260    def setUp(self): 
    6361        self.canvas = VolumeCanvas.VolumeCanvas() 
    64          
    65          
     62 
     63 
    6664    def testSetQmax(self): 
    6765        old_value = self.canvas.getParam('q_max') 
    6866        new_value = old_value + 0.1 
    6967        self.canvas.setParam('q_max', new_value) 
    70         self.assertEqual(self.canvas.getParam("Q_MAx"), new_value)          
    71          
    72     def testSetDensity(self):         
     68        self.assertEqual(self.canvas.getParam("Q_MAx"), new_value) 
     69 
     70    def testSetDensity(self): 
    7371        self.canvas.setParam('lores_density', 0.1) 
    7472        handle = self.canvas.add('sphere') 
     
    7775        npts_1 = vol/0.1 
    7876        value_1 = self.canvas.getIq(0.001) 
    79          
     77 
    8078        # Change density, the answer should be the same 
    8179        self.canvas.setParam('lores_density', 0.2) 
    8280        npts_2 = vol/0.2 
    8381        value_2 = self.canvas.getIq(0.001) 
    84          
    85         self.assert_( (value_1-value_2)/value_1 < 0.1)          
    86          
    87     def testSetDensityTiming(self):       
     82 
     83        self.assert_( (value_1-value_2)/value_1 < 0.1) 
     84 
     85    def testSetDensityTiming(self): 
    8886        """Testing change in computation time with density""" 
    8987        handle = self.canvas.add('sphere') 
    9088        self.canvas.setParam("%s.radius" % handle, 15.0) 
    91          
     89 
    9290        self.canvas.setParam('lores_density', 0.6) 
    9391        t_0 = time.time() 
    9492        self.canvas.getIq(0.001) 
    9593        t_1 = time.time()-t_0 
    96          
     94 
    9795        # Change density, the answer should be the same 
    9896        self.canvas.setParam('lores_density', 0.1) 
     
    10098        self.canvas.getIq(0.001) 
    10199        t_2 = time.time()-t_0 
    102          
    103         self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2)          
    104          
     100 
     101        self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2) 
     102 
    105103    def testGetParamList(self): 
    106104        """ Test GetParamList on empty canvas""" 
    107105        self.assert_('lores_density' in self.canvas.getParamList()) 
    108106        handle = self.canvas.add('sphere') 
    109          
     107 
    110108    def testGetParamListWithShape(self): 
    111109        """ Test GetParamList on filled canvas""" 
    112110        self.canvas.add('sphere') 
    113111        self.assert_('lores_density' in self.canvas.getParamList()) 
    114          
     112 
    115113    def testAdd(self): 
    116114        handle = "s1" 
    117115        self.assertEqual(handle, self.canvas.add('sphere', handle)) 
    118   
     116 
    119117        #TODO: test for current list of shape 
    120118        self.assertEqual( [handle] , self.canvas.getShapeList()) 
    121          
     119 
    122120    def testSetRadius(self): 
    123121        handle = self.canvas.add('sphere') 
    124         self.canvas.setParam("%s.rAdius" % handle, 24.0) 
    125         self.assertEqual(self.canvas.getParam("%s.rAdius" % handle), 24.0) 
     122        self.canvas.setParam("%s.radius" % handle, 24.0) 
     123        self.assertEqual(self.canvas.getParam("%s.radius" % handle), 24.0) 
    126124 
    127125    def testGetIq(self): 
    128126        """ Test the output of I(q) to the analytical solution 
    129127            If the normalization is wrong, we will have to fix it. 
    130              
     128 
    131129            getIq() should call getPr() behind the scenes so that 
    132130            the user doesnt have to do it if he doesn't need to. 
    133131        """ 
    134         from sas.models.SphereModel import SphereModel 
    135132        sphere = SphereModel() 
     133        sphere.setParam('scale', 1.0) 
     134        sphere.setParam('background', 0.0) 
     135        sphere.setParam('sld', 1.0) 
     136        sphere.setParam('sld_solvent', 0.0) 
    136137        sphere.setParam('radius', 10.0) 
    137         sphere.setParam('contrast', 1.0) 
    138         sphere.setParam('background', 0.0) 
    139         sphere.setParam('scale', 1.0) 
    140                  
     138 
    141139        handle = self.canvas.add('sphere') 
    142140        self.canvas.setParam('%s.radius' % handle, 10.0) 
    143141        self.canvas.setParam('%s.contrast' % handle, 1.0) 
    144          
    145          
     142 
     143 
    146144        sim_1 = self.canvas.getIq(0.001) 
    147145        ana_1 = sphere.run(0.001) 
    148146        sim_2 = self.canvas.getIq(0.01) 
    149147        ana_2 = sphere.run(0.01) 
    150          
    151         # test the shape of the curve (calculate relative error  
     148 
     149        # test the shape of the curve (calculate relative error 
    152150        # on the output and it should be compatible with zero 
    153151        # THIS WILL DEPEND ON THE NUMBER OF SPACE POINTS: 
    154152        # that why we need some error analysis. 
    155153        self.assert_( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1) 
    156          
     154 
    157155        # test the absolute amplitude 
    158156        self.assert_( math.fabs(sim_2-ana_2)/ana_2 < 0.1) 
    159          
     157 
    160158    def testGetIq2(self): 
    161159        """ Test two different q values 
     
    163161        handle = self.canvas.add('sphere') 
    164162        self.canvas.setParam('%s.radius' % handle, 10.0) 
    165          
     163 
    166164        sim_1 = self.canvas.getIq(0.001) 
    167165        sim_2 = self.canvas.getIq(0.01) 
    168          
     166 
    169167        self.assertNotAlmostEqual(sim_2, sim_1, 3) 
    170          
     168 
    171169    def testGetIq_Identical(self): 
    172170        """ Test for identical model / no param change 
     
    174172        handle = self.canvas.add('sphere') 
    175173        self.canvas.setParam('%s.radius' % handle, 10.0) 
    176          
     174 
    177175        sim_1 = self.canvas.getIq(0.01) 
    178176        sim_2 = self.canvas.getIq(0.01) 
    179          
     177 
    180178        self.assertEqual(sim_2, sim_1) 
    181          
     179 
    182180    def testGetIq_Identical2(self): 
    183181        """ Test for identical model after a parameter change 
     
    187185        handle = self.canvas.add('sphere') 
    188186        self.canvas.setParam('%s.radius' % handle, 10.0) 
    189          
     187 
    190188        self.canvas.setParam('lores_density', 0.1) 
    191189        sim_1 = self.canvas.getIq(0.01) 
    192          
     190 
    193191        # Try to fool the code by changing to a different value 
    194192        self.canvas.setParam('lores_density', 0.2) 
    195193        self.canvas.getIq(0.01) 
    196          
    197         self.canvas.setParam('lores_density', 0.1) 
    198         sim_2 = self.canvas.getIq(0.01) 
    199          
     194 
     195        self.canvas.setParam('lores_density', 0.1) 
     196        sim_2 = self.canvas.getIq(0.01) 
     197 
    200198        self.assert_((sim_2-sim_1)/sim_1<0.05) 
    201          
     199 
    202200    def testGetIq_time(self): 
    203201        """ Time profile 
     
    205203        handle = self.canvas.add('sphere') 
    206204        self.canvas.setParam('%s.radius' % handle, 15.0) 
    207          
    208          
     205 
     206 
    209207        self.canvas.setParam('lores_density', 0.1) 
    210208        t_0 = time.time() 
    211209        sim_1 = self.canvas.getIq(0.01) 
    212210        delta_1 = time.time()-t_0 
    213          
    214         self.canvas.setParam('lores_density', 0.1) 
    215          
     211 
     212        self.canvas.setParam('lores_density', 0.1) 
     213 
    216214        t_0 = time.time() 
    217215        sim_2 = self.canvas.getIq(0.01) 
    218216        delta_2 = time.time()-t_0 
    219          
     217 
    220218        self.assert_((delta_2-delta_1)/delta_1<0.05) 
    221          
    222          
     219 
     220 
    223221    def testGetPr(self): 
    224222        """Compare the output of P(r) to the theoretical value""" 
     
    231229            get the right output after changing a parameter 
    232230        """ 
    233          
     231 
    234232        handle = self.canvas.add('sphere') 
    235233        self.canvas.setParam('%s.radius' % handle, 10.0) 
     
    291289        result_3 = self.canvas.getIq(0.1) 
    292290        self.assertNotEqual(result_1, result_3) 
    293          
     291 
    294292class TestOrdering(unittest.TestCase): 
    295293    """ Unit tests for all shapes in canvas model """ 
    296294 
    297295    def setUp(self): 
    298         from sas.models.CoreShellModel import CoreShellModel 
    299296        radius = 15 
    300297        thickness = 5 
     
    303300        shell_vol = 4.0/3.0*math.pi*outer_radius*outer_radius*outer_radius - core_vol 
    304301        self.shell_sld = -1.0*core_vol/shell_vol 
    305          
     302 
    306303        self.canvas = VolumeCanvas.VolumeCanvas() 
    307304        self.canvas.params['lores_density'] = 0.1 
    308          
     305 
    309306        # Core shell model 
    310307        sphere = CoreShellModel() 
     308        sphere.setParam('scale', 1.0) 
     309        sphere.setParam('background', 0.0) 
     310        sphere.setParam('sld_core', 1.0) 
     311        sphere.setParam('sld_shell', self.shell_sld) 
     312        sphere.setParam('sld_solvent', 0.0) 
    311313        # Core radius 
    312314        sphere.setParam('radius', radius) 
    313315        # Shell thickness 
    314316        sphere.setParam('thickness', thickness) 
    315         sphere.setParam('core_sld', 1.0) 
    316         sphere.setParam('shell_sld', self.shell_sld) 
    317         sphere.setParam('solvent_sld', 0.0) 
    318         sphere.setParam('background', 0.0) 
    319         sphere.setParam('scale', 1.0) 
    320317        self.sphere = sphere 
    321318        self.radius = radius 
    322319        self.outer_radius = outer_radius 
    323          
     320 
    324321    def set_coreshell_on_canvas(self, order1=None, order2=None): 
    325322 
    326323        handle = self.canvas.add('sphere') 
     324        self.canvas.setParam('scale' , 1.0) 
     325        self.canvas.setParam('background' , 0.0) 
     326 
    327327        self.canvas.setParam('%s.radius' % handle, self.outer_radius) 
    328328        self.canvas.setParam('%s.contrast' % handle, self.shell_sld) 
    329329        if order1 is not None: 
    330330            self.canvas.setParam('%s.order' % handle, order1) 
    331         
     331 
    332332        handle2 = self.canvas.add('sphere') 
    333333        self.canvas.setParam('%s.radius' % handle2, self.radius) 
     
    335335        if order2 is not None: 
    336336            self.canvas.setParam('%s.order' % handle2, order2) 
    337                 
    338         self.canvas.setParam('scale' , 1.0) 
    339         self.canvas.setParam('background' , 0.0) 
    340          
    341          
     337 
     338 
    342339    def testDefaultOrder(self): 
    343340        self.set_coreshell_on_canvas() 
    344          
     341 
    345342        ana = self.sphere.run(0.05) 
    346343        val, err = self.canvas.getIqError(0.05) 
    347344        self.assert_(math.fabs(ana-val)<2.0*err) 
    348          
     345 
    349346    def testRightOrder(self): 
    350347        self.set_coreshell_on_canvas(3.0, 6.0) 
    351          
     348 
    352349        ana = self.sphere.run(0.05) 
    353350        val, err = self.canvas.getIqError(0.05) 
    354351        #print 'right', ana, val, err 
    355352        self.assert_(math.fabs(ana-val)/ana < 1.1) 
    356          
     353 
    357354    def testWrongOrder(self): 
    358         from sas.models.SphereModel import SphereModel 
    359355        self.set_coreshell_on_canvas(1, 0) 
    360          
    361         # Core shell model 
     356 
    362357        sphere = SphereModel() 
    363         # Core radius 
     358        sphere.setParam('scale', 1.0) 
     359        sphere.setParam('background', 0.0) 
    364360        sphere.setParam('radius', self.outer_radius) 
    365         # Shell thickness 
    366         sphere.setParam('contrast', self.shell_sld) 
    367         sphere.setParam('background', 0.0) 
    368         sphere.setParam('scale', 1.0) 
    369          
     361        sphere.setParam('sld', self.shell_sld) 
     362        sphere.setParam('sld_solvent', 0.0) 
     363 
    370364        ana = sphere.run(0.05) 
    371365        val, err = self.canvas.getIqError(0.05) 
    372366        #print 'wrong', ana, val, err 
    373367        self.assert_(math.fabs(ana-val)/ana < 1.1) 
    374              
    375          
     368 
     369 
    376370if __name__ == '__main__': 
    377371    unittest.main() 
Note: See TracChangeset for help on using the changeset viewer.