Changeset 2f17d40 in sasview for test


Ignore:
Timestamp:
May 16, 2017 6:16:20 AM (7 years ago)
Author:
GitHub <noreply@…>
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.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
81b1f4d
Parents:
658dd57 (diff), 8e9536f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Adam Washington <rprospero@…> (05/16/17 06:16:20)
git-committer:
GitHub <noreply@…> (05/16/17 06:16:20)
Message:

Merge pull request #76 from rprospero/master

Update SESANS reader to file format 1.0

Location:
test
Files:
8 added
4 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • test/fileconverter/test/utest_nxcansas_writer.py

    rc476457 r17c9436  
    6666        if os.path.isfile(self.write_file_1d): 
    6767            os.remove(self.write_file_1d) 
     68        if os.path.isfile(self.write_file_2d): 
     69            os.remove(self.write_file_2d) 

  • test/pr_inversion/test/utest_invertor.py

    rac07a3a raaf5e49  
    66# Disable "too many methods" complaint  
    77# pylint: disable-msg=R0904  
    8  
    9  
    10 import unittest, math, numpy 
     8from __future__ import print_function 
     9 
     10 
     11import os 
     12import unittest 
     13import math 
     14import numpy 
    1115from sas.sascalc.pr.invertor import Invertor 
    12          
     16 
     17 
    1318class TestFiguresOfMerit(unittest.TestCase): 
    1419             
    … …  
    235240            self.assertTrue(chi2/51.0<10.0) 
    236241        except: 
    237             print "chi2 =", chi2/51.0 
     242            print("chi2 =", chi2/51.0) 
    238243            raise 
    239244         
    … …  
    263268            self.assertTrue(self.invertor.chi2/len(x)<200.00) 
    264269        except: 
    265             print "Chi2(I(q)) =", self.invertor.chi2/len(x) 
     270            print("Chi2(I(q)) =", self.invertor.chi2/len(x)) 
    266271            raise 
    267272         
    … …  
    297302            self.assertTrue(chi2/51.0<50.0) 
    298303        except: 
    299             print "chi2(P(r)) =", chi2/51.0 
     304            print("chi2(P(r)) =", chi2/51.0) 
    300305            raise 
    301306         
    … …  
    341346            self.assertTrue(self.invertor.chi2>0) 
    342347        except: 
    343             print "Chi2 =", self.invertor.chi2 
     348            print("Chi2 =", self.invertor.chi2) 
    344349            raise 
    345350                             
    … …  
    365370            self.assertTrue(self.invertor.chi2>0) 
    366371        except: 
    367             print "Chi2 =", self.invertor.chi2 
     372            print("Chi2 =", self.invertor.chi2) 
    368373            raise 
    369374         
    … …  
    416421         
    417422        # Save 
    418         self.invertor.to_file("test_output.txt") 
     423        f_name = "test_output.txt" 
     424        self.invertor.to_file(f_name) 
    419425     
    420426        # Load 
    421         self.invertor.from_file("test_output.txt") 
     427        self.invertor.from_file(f_name) 
    422428        self.assertEqual(self.invertor.d_max, 160.0) 
    423429        self.assertEqual(self.invertor.alpha, 0.0007) 
    424430        self.assertEqual(self.invertor.chi2, 836.797) 
    425431        self.assertAlmostEqual(self.invertor.pr(self.invertor.out, 10.0), 903.31577041, 4) 
     432        if os.path.isfile(f_name): 
     433            os.remove(f_name) 
    426434         
    427435    def test_qmin(self): 

  • test/run_one.py

    raaad4c95 raaf5e49  
    11#!/usr/bin/env python 
     2from __future__ import print_function 
    23 
    34import os 
    … …  
    2425#print "\n".join(sys.path) 
    2526test_path,test_file = splitpath(abspath(sys.argv[1])) 
    26 print "=== testing:",sys.argv[1] 
     27print("=== testing:",sys.argv[1]) 
    2728#print test_path, test_file 
    2829sys.argv = [sys.argv[0]] 

  • test/sasdataloader/plugins/test_reader.py

    r959eb01 raaf5e49  
    88copyright 2008, University of Tennessee 
    99""" 
     10from __future__ import print_function 
     11 
    1012import os 
    1113import numpy as np 
    … …  
    5961    reader = Reader() 
    6062    output = reader.read("../test/test_data.test") 
    61     print output.x 
     63    print(output.x) 
    6264     
    6365     

  • test/sasdataloader/test/sequence_tests.py

    r959eb01 raaf5e49  
     1from __future__ import print_function 
     2 
    13from DataLoader.loader import Loader 
    24from DataLoader.readers.IgorReader import Reader as igor_reader 
    … …  
    810    out2 = Loader().load("MAR07232_rest.ASC") 
    911    if len(out2.detector)>1: 
    10         print "Consecutive reads using Loader failed" 
     12        print("Consecutive reads using Loader failed") 
    1113 
    1214def consecutive_reader(): 
    … …  
    1416    out2 = igor_reader().read("MAR07232_rest.ASC") 
    1517    if len(out2.detector)>1: 
    16         print "Consecutive reads using Readers failed" 
    17         print out1 
    18         print out2 
     18        print("Consecutive reads using Readers failed") 
     19        print(out1) 
     20        print(out2) 
    1921 
    2022def single_abs(): 
    … …  
    2931    single_igor() 
    3032    single_abs() 
    31     print "Test passed" 
     33    print("Test passed") 

  • test/sasdataloader/test/testplugings.py

    r959eb01 r17c9436  
    33""" 
    44 
     5import os 
    56import unittest 
    67from sas.sascalc.dataloader.loader import  Loader, Registry 
    … …  
    4142        # Create module 
    4243        import zipfile 
    43         z = zipfile.PyZipFile("plugins.zip", 'w') 
     44        f_name = "plugins.zip" 
     45        z = zipfile.PyZipFile(f_name, 'w') 
    4446        z.writepy("../plugins", "") 
    4547        z.close() 
     48        if os.path.isfile(f_name): 
     49            os.remove(f_name) 
    4650         
    4751    def testplugin_checksetup(self): 

  • test/sasdataloader/test/utest_abs_reader.py

    rdd11014 rc551bb3  
    22    Unit tests for data manipulations 
    33""" 
     4from __future__ import print_function 
    45 
    56import unittest 
    … …  
    89from sas.sascalc.dataloader.loader import Loader 
    910from sas.sascalc.dataloader.readers.IgorReader import Reader as IgorReader 
     11from sas.sascalc.dataloader.readers.abs_reader import Reader as AbsReader 
     12from sas.sascalc.dataloader.readers.hfir1d_reader import Reader as HFIRReader 
     13from sas.sascalc.dataloader.readers.danse_reader import Reader as DANSEReader 
     14from sas.sascalc.dataloader.readers.cansas_reader import Reader as CANSASReader 
     15 
    1016from sas.sascalc.dataloader.data_info import Data1D 
    1117  
    1218import os.path 
    1319 
     20 
    1421class abs_reader(unittest.TestCase): 
    1522     
    1623    def setUp(self): 
    17         from sas.sascalc.dataloader.readers.abs_reader import Reader 
    18         self.data = Reader().read("jan08002.ABS") 
    19          
     24        reader = AbsReader() 
     25        self.data = reader.read("jan08002.ABS") 
     26 
    2027    def test_abs_checkdata(self): 
    2128        """ 
    … …  
    6168    def test_checkdata2(self): 
    6269        self.assertEqual(self.data.dy[126], 1) 
    63          
     70 
     71    def test_generic_loader(self): 
     72        # the generic loader should work as well 
     73        data = Loader().load("jan08002.ABS") 
     74        self.assertEqual(data.meta_data['loader'], "IGOR 1D") 
     75 
     76 
    6477class hfir_reader(unittest.TestCase): 
    65      
     78 
    6679    def setUp(self): 
    67         self.data = Loader().load("S2-30dq.d1d") 
    68          
     80        reader = HFIRReader() 
     81        self.data = reader.read("S2-30dq.d1d") 
     82 
    6983    def test_hfir_checkdata(self): 
    7084        """ 
    … …  
    8397        self.assertEqual(self.data.dy[1], 0.000315) 
    8498        self.assertEqual(self.data.dx[1], 0.008249) 
    85          
     99 
     100    def test_generic_loader(self): 
     101        # the generic loader should work as well 
     102        data = Loader().load("S2-30dq.d1d") 
     103        self.assertEqual(data.meta_data['loader'], "HFIR 1D") 
     104 
    86105 
    87106class igor_reader(unittest.TestCase): 
    … …  
    137156     
    138157    def setUp(self): 
    139         self.data = Loader().load("MP_New.sans") 
     158        reader = DANSEReader() 
     159        self.data = reader.read("MP_New.sans") 
    140160 
    141161    def test_checkdata(self): 
    … …  
    171191        self.assertEqual(self.data.err_data[2], 2.06313) 
    172192 
     193    def test_generic_loader(self): 
     194        # the generic loader should work as well 
     195        data = Loader().load("MP_New.sans") 
     196        self.assertEqual(data.meta_data['loader'], "DANSE") 
     197 
    173198  
    174199class cansas_reader(unittest.TestCase): 
    175200     
    176201    def setUp(self): 
     202        reader = CANSASReader() 
     203        data = reader.read("cansas1d.xml") 
     204        self.data = data[0] 
     205 
     206    def test_generic_loader(self): 
     207        # the generic loader should work as well 
    177208        data = Loader().load("cansas1d.xml") 
    178         self.data = data[0] 
    179   
     209        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D") 
     210 
    180211    def test_cansas_checkdata(self): 
    181212        self.assertEqual(self.data.filename, "cansas1d.xml") 
    … …  
    190221            tests won't pass 
    191222        """ 
    192          
    193223        self.assertEqual(self.data.run[0], "1234") 
    194224        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    … …  
    264294            self.assertEqual(item.distance_unit,'mm') 
    265295 
    266             if item.size.x==50 \ 
    267                 and item.distance==11000.0 \ 
    268                 and item.name=='source' \ 
    269                 and item.type=='radius': 
     296            if item.size.x == 50 \ 
     297                and item.distance == 11000.0 \ 
     298                and item.name == 'source' \ 
     299                and item.type == 'radius': 
    270300                _found1 = True 
    271             elif item.size.x==1.0 \ 
    272                 and item.name=='sample' \ 
    273                 and item.type=='radius': 
     301            elif item.size.x == 1.0 \ 
     302                and item.name == 'sample' \ 
     303                and item.type == 'radius': 
    274304                _found2 = True 
    275305                 
    276         if _found1==False or _found2==False: 
     306        if _found1 == False or _found2 == False: 
    277307            raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2)  
    278308             
    … …  
    309339            self.assertTrue(item.date in ['04-Sep-2007 18:35:02', 
    310340                                          '03-SEP-2006 11:42:47']) 
    311             print item.term 
     341            print(item.term) 
    312342            for t in item.term: 
    313                 if t['name']=="ABS:DSTAND" \ 
    314                     and t['unit']=='mm' \ 
    315                     and float(t['value'])==1.0: 
     343                if (t['name'] == "ABS:DSTAND" 
     344                    and t['unit'] == 'mm' 
     345                    and float(t['value']) == 1.0): 
    316346                    _found_term2 = True 
    317                 elif t['name']=="radialstep" \ 
    318                     and t['unit']=='mm' \ 
    319                     and float(t['value'])==10.0: 
     347                elif (t['name'] == "radialstep" 
     348                      and t['unit'] == 'mm' 
     349                      and float(t['value']) == 10.0): 
    320350                    _found_term1 = True 
    321351                     
    322         if _found_term1==False or _found_term2==False: 
    323             raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2)  
    324              
    325          
    326          
     352        if _found_term1 == False or _found_term2 == False: 
     353            raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2) 
    327354         
    328355    def test_writer(self): 
    329         from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    330         r = Reader() 
    331         x = np.ones(5) 
    332         y = np.ones(5) 
    333         dy = np.ones(5) 
    334          
     356        r = CANSASReader() 
     357 
    335358        filename = "write_test.xml" 
    336359        r.write(filename, self.data) 
    … …  
    339362        self.assertEqual(self.data.filename, filename) 
    340363        self._checkdata() 
     364        if os.path.isfile(filename): 
     365            os.remove(filename) 
    341366         
    342367    def test_units(self): 
    … …  
    346371        """ 
    347372        filename = "cansas1d_units.xml" 
    348         data = Loader().load(filename) 
     373        data = CANSASReader().read(filename) 
    349374        self.data = data[0] 
    350375        self.assertEqual(self.data.filename, filename) 
    … …  
    357382        """ 
    358383        filename = "cansas1d_badunits.xml" 
    359         data = Loader().load(filename) 
     384        data = CANSASReader().read(filename) 
    360385        self.data = data[0] 
    361386        self.assertEqual(self.data.filename, filename) 
    … …  
    366391         
    367392        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    368         print self.data.errors 
     393        print(self.data.errors) 
    369394        self.assertEqual(len(self.data.errors), 1) 
    370          
    371          
     395 
    372396    def test_slits(self): 
    373397        """ 
    … …  
    375399        """ 
    376400        filename = "cansas1d_slit.xml" 
    377         data = Loader().load(filename) 
     401        data = CANSASReader().read(filename) 
    378402        self.data = data[0] 
    379403        self.assertEqual(self.data.filename, filename) 
    … …  
    397421        self.assertEqual(self.data.run_name['1234'], 'run name') 
    398422        self.assertEqual(self.data.title, "Test title") 
    399          
    400              
     423 
    401424 
    402425if __name__ == '__main__': 

  • test/sasdataloader/test/utest_cansas.py

    r7432acb r1fc50fb2  
    4646        self.schema_1_0 = "cansas1d_v1_0.xsd" 
    4747        self.schema_1_1 = "cansas1d_v1_1.xsd" 
    48  
     48        self.write_1_0_filename = "isis_1_0_write_test.xml" 
     49        self.write_1_1_filename = "isis_1_1_write_test.xml" 
    4950 
    5051    def get_number_of_entries(self, dictionary, name, i): 
    … …  
    5657        return name 
    5758 
    58  
    5959    def test_invalid_xml(self): 
    6060        """ 
    … …  
    6262        """ 
    6363        invalid = StringIO.StringIO('<a><c></b></a>') 
    64         reader = XMLreader(invalid) 
    65  
     64        XMLreader(invalid) 
    6665 
    6766    def test_xml_validate(self): 
    … …  
    8281        self.assertFalse(xmlschema.validate(invalid)) 
    8382 
    84  
    8583    def test_real_xml(self): 
    8684        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    … …  
    9088        else: 
    9189            self.assertFalse(valid) 
    92  
    9390 
    9491    def _check_data(self, data): 
    … …  
    105102        self.assertTrue(data.meta_data["xmlpreprocess"] is not None) 
    106103 
    107  
    108104    def _check_data_1_1(self, data): 
    109105        spectrum = data.trans_spectrum[0] 
    110106        self.assertTrue(len(spectrum.wavelength) == 138) 
    111107 
    112  
    113108    def test_cansas_xml(self): 
    114         filename = "isis_1_1_write_test.xml" 
    115109        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1) 
    116110        valid = xmlreader.validate_xml() 
    117111        xmlreader.set_processing_instructions() 
    118112        self.assertTrue(valid) 
    119         fo = open(self.isis_1_1) 
    120         str = fo.read() 
    121113        reader_generic = Loader() 
    122114        dataloader = reader_generic.load(self.isis_1_1) 
    … …  
    128120            self._check_data(cansasreader[i]) 
    129121            self._check_data_1_1(cansasreader[i]) 
    130             reader_generic.save(filename, dataloader[i], None) 
    131             fo = open(filename) 
    132             str = fo.read() 
     122            reader_generic.save(self.write_1_1_filename, dataloader[i], None) 
    133123            reader2 = Loader() 
    134             return_data = reader2.load(filename) 
     124            self.assertTrue(os.path.isfile(self.write_1_1_filename)) 
     125            return_data = reader2.load(self.write_1_1_filename) 
    135126            written_data = return_data[0] 
    136127            self._check_data(written_data) 
    137  
     128        if os.path.isfile(self.write_1_1_filename): 
     129            os.remove(self.write_1_1_filename) 
    138130 
    139131    def test_double_trans_spectra(self): 
    … …  
    144136        for item in data: 
    145137            self._check_data(item) 
    146  
    147138 
    148139    def test_entry_name_recurse(self): 
    … …  
    155146        self.assertTrue(len(d) == 6) 
    156147 
    157  
    158148    def test_load_cansas_file(self): 
    159         valid = [] 
    160149        reader1 = XMLreader(self.xml_valid, self.schema_1_0) 
    161150        self.assertTrue(reader1.validate_xml()) 
    … …  
    173162        self.assertFalse(reader7.validate_xml()) 
    174163 
    175  
    176164    def test_invalid_cansas(self): 
    177165        list = self.loader.load(self.cansas1d_notitle) 
    … …  
    184172        self.assertTrue(data.detector[0].distance == 4150) 
    185173 
    186  
    187174    def test_old_cansas_files(self): 
    188175        reader1 = XMLreader(self.cansas1d, self.schema_1_0) 
    189176        self.assertTrue(reader1.validate_xml()) 
    190177        file_loader = Loader() 
    191         file1 = file_loader.load(self.cansas1d) 
     178        file_loader.load(self.cansas1d) 
    192179        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0) 
    193180        self.assertTrue(reader2.validate_xml()) 
    … …  
    197184        self.assertTrue(reader4.validate_xml()) 
    198185 
    199  
    200186    def test_save_cansas_v1_0(self): 
    201         filename = "isis_1_0_write_test.xml" 
    202187        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    203188        valid = xmlreader.validate_xml() 
    … …  
    210195            self._check_data(dataloader[i]) 
    211196            self._check_data(cansasreader[i]) 
    212             reader_generic.save(filename, dataloader[i], None) 
     197            reader_generic.save(self.write_1_0_filename, dataloader[i], None) 
    213198            reader2 = Reader() 
    214             return_data = reader2.read(filename) 
     199            self.assertTrue(os.path.isfile(self.write_1_0_filename)) 
     200            return_data = reader2.read(self.write_1_0_filename) 
    215201            written_data = return_data[0] 
    216             xmlwrite = XMLreader(filename, self.schema_1_0) 
     202            XMLreader(self.write_1_0_filename, self.schema_1_0) 
    217203            valid = xmlreader.validate_xml() 
    218204            self.assertTrue(valid) 
    219205            self._check_data(written_data) 
    220  
     206        if os.path.isfile(self.write_1_0_filename): 
     207            os.remove(self.write_1_0_filename) 
    221208 
    222209    def test_processing_instructions(self): 
    … …  
    224211        valid = reader.validate_xml() 
    225212        if valid: 
    226             ## find the processing instructions and make into a dictionary 
     213            # find the processing instructions and make into a dictionary 
    227214            dic = self.get_processing_instructions(reader) 
    228215            self.assertTrue(dic == {'xml-stylesheet': \ 
    … …  
    232219            xmldoc = minidom.parseString(xml) 
    233220 
    234             ## take the processing instructions and put them back in 
     221            # take the processing instructions and put them back in 
    235222            xmldoc = self.set_processing_instructions(xmldoc, dic) 
    236             xml_output = xmldoc.toprettyxml() 
    237  
     223            xmldoc.toprettyxml() 
    238224 
    239225    def set_processing_instructions(self, minidom_object, dic): 
    … …  
    243229            minidom_object.insertBefore(pi, xmlroot) 
    244230        return minidom_object 
    245  
    246231 
    247232    def get_processing_instructions(self, xml_reader_object): 

  • test/sasrealspace/test/early_test.py

    r959eb01 raaf5e49  
     1from __future__ import print_function 
    12 
    23import VolumeCanvas 
    … …  
    3031        t_0 = time.time() 
    3132        value_1 = 1.0e8*canvas.getIq(0.1) 
    32         print "density = 0.1:  output=%g  time=%g" % (value_1, time.time()-t_0) 
     33        print("density = 0.1:  output=%g  time=%g" % (value_1, time.time()-t_0)) 
    3334         
    3435        t_0 = time.time() 
    3536        canvas.setParam('lores_density', 1) 
    3637        value_1 = 1.0e8*canvas.getIq(0.1) 
    37         print "density = 1000:  output=%g  time=%g" % (value_1, time.time()-t_0) 
     38        print("density = 1000:  output=%g  time=%g" % (value_1, time.time()-t_0)) 
    3839         
    3940        t_0 = time.time() 
    4041        canvas.setParam('lores_density', 0.01) 
    4142        value_1 = 1.0e8*canvas.getIq(0.1) 
    42         print "density = 0.00001:  output=%g  time=%g" % (value_1, time.time()-t_0) 
    43         print 
     43        print("density = 0.00001:  output=%g  time=%g" % (value_1, time.time()-t_0)) 
     44        print() 
    4445     
    4546     
    … …  
    6364        #ana_1 = form_factor(q, radius) 
    6465         
    65         print "q=%g  sim=%g  ana=%g   ratio=%g" % (q, sim_1, ana_1, sim_1/ana_1) 
     66        print("q=%g  sim=%g  ana=%g   ratio=%g" % (q, sim_1, ana_1, sim_1/ana_1)) 
    6667     
    6768def test_2(): 
    … …  
    7374    shell_vol = 4.0/3.0*math.pi*outer_radius*outer_radius*outer_radius - core_vol 
    7475    shell_sld = -1.0*core_vol/shell_vol 
    75     print "Shell SLD", shell_sld 
     76    print("Shell SLD", shell_sld) 
    7677 
    7778     
    … …  
    126127        ana_1 = sphere.run(q) 
    127128         
    128         print "q=%g  sim=%g  ana=%g   ratio=%g" % (q, sim_1, ana_1, sim_1/ana_1) 
     129        print("q=%g  sim=%g  ana=%g   ratio=%g" % (q, sim_1, ana_1, sim_1/ana_1)) 
    129130        out.write( "%g  %g  %g\n" % (q, sim_1, ana_1)) 
    130131 
    … …  
    168169        #ana_1 = form_factor(q, radius) 
    169170         
    170         print "q=%g  sim=%g  ana=%g   ratio=%g" % (q, sim_1, ana_1, sim_1/ana_1) 
     171        print("q=%g  sim=%g  ana=%g   ratio=%g" % (q, sim_1, ana_1, sim_1/ana_1)) 
    171172 
    172173def test_5(): 
    … …  
    193194    ana = ana.runXY([0.1, 0.1]) 
    194195    sim = model.getIq2D(0.1, 0.1) 
    195     print ana, sim, sim/ana, ana/sim 
     196    print(ana, sim, sim/ana, ana/sim) 
    196197 
    197198def test_6(): 
    … …  
    232233     
    233234     
    234     print model.npts 
     235    print(model.npts) 
    235236    for i in range(40): 
    236237        qmax = 0.5 
    … …  
    240241        anaY = ana.runXY([0, qmax*i/40.0]) 
    241242        simY = model.getIq2D(0, qmax*i/40.0) 
    242         print anaX, simX, simX/anaX, '|', anaY, simY, simY/anaY 
     243        print(anaX, simX, simX/anaX, '|', anaY, simY, simY/anaY) 
    243244     
    244245def test_7(): 
    245246    from sas.models.CoreShellModel import CoreShellModel 
    246     print "Testing core-shell" 
     247    print("Testing core-shell") 
    247248    radius = 15 
    248249    thickness = 5 
    … …  
    287288        ana_val = ana.runXY([q, 0.2]) 
    288289        sim_val, err = canvas.getIq2DError(q, 0.2) 
    289         print ana_val, sim_val, sim_val/ana_val, err, (sim_val-ana_val)/err 
     290        print(ana_val, sim_val, sim_val/ana_val, err, (sim_val-ana_val)/err) 
    290291     
    291292     

  • test/sasrealspace/test/sim_validation.py

    rac07a3a raaf5e49  
    55    @license: This software is provided as part of the DANSE project 
    66""" 
     7from __future__ import print_function 
     8 
    79import math, time, pylab 
    810 
    911try: 
    1012    import VolumeCanvas 
    11     print "Testing local version" 
     13    print("Testing local version") 
    1214except: 
    13     print "Testing installed version" 
     15    print("Testing installed version") 
    1416    import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    1517      
    … …  
    250252        ana = validator.run_ana(q) 
    251253        sim, err = validator.run_sim(q) 
    252         print "q=%-g  ana=%-g  sim=%-g  err=%-g  diff=%-g (%-g) %s" % (q, ana, sim, err,  
    253                         (sim-ana), sim/ana, str(math.fabs(sim-ana)>err)) 
     254        print("q=%-g  ana=%-g  sim=%-g  err=%-g  diff=%-g (%-g) %s" % (q, ana, sim, err,  
     255                        (sim-ana), sim/ana, str(math.fabs(sim-ana)>err))) 
    254256        output.write("%g  %g  %g  %g\n" % (q, ana, sim, err)) 
    255257    output.close() 
    … …  
    278280        ana = validator.run_ana2D(q*math.cos(phi), q*math.sin(phi)) 
    279281        sim, err = validator.run_sim2D(q*math.cos(phi), q*math.sin(phi)) 
    280         print "q=%-g  ana=%-g  sim=%-g  err=%-g  diff=%-g (%-g) %s" % (q, ana, sim, err,  
    281                         (sim-ana), sim/ana, str(math.fabs(sim-ana)>err)) 
     282        print("q=%-g  ana=%-g  sim=%-g  err=%-g  diff=%-g (%-g) %s" % (q, ana, sim, err,  
     283                        (sim-ana), sim/ana, str(math.fabs(sim-ana)>err))) 
    282284        output.write("%g  %g  %g  %g\n" % (q, ana, sim, err)) 
    283     print "Time elapsed: ", time.time()-t_0 
     285    print("Time elapsed: ", time.time()-t_0) 
    284286    output.close() 
    285287        
    … …  
    306308    for d in d_list: 
    307309        sim, err = validator.run_sim(q, density=d) 
    308         print "d=%-g  ana=%-g  sim=%-g  err=%-g  diff=%-g (%g) %s" % \ 
     310        print("d=%-g  ana=%-g  sim=%-g  err=%-g  diff=%-g (%g) %s" % \ 
    309311            (d, ana, sim, err, (sim-ana), (sim-ana)/ana,  
    310              str(math.fabs(sim-ana)>err)) 
     312             str(math.fabs(sim-ana)>err))) 
    311313        output.write("%g  %g  %g  %g \n" % (d, ana, sim, err)) 
    312314    output.close() 

  • test/sasrealspace/test/utest_oriented.py

    r959eb01 raaf5e49  
    33    @copyright: University of Tennessee, for the DANSE project 
    44""" 
     5from __future__ import print_function 
    56 
    67import unittest, math, sys 
    … …  
    1617try: 
    1718    import VolumeCanvas 
    18     print "Testing local version" 
     19    print("Testing local version") 
    1920except: 
    20     print sys.exc_value 
     21    print(sys.exc_value) 
    2122    #testing the version that is working on 
    22     print "Testing installed version" 
     23    print("Testing installed version") 
    2324    import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    2425  
    … …  
    241242            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    242243        except: 
    243             print "Error", ana_val, sim_val, sim_val/ana_val 
     244            print("Error", ana_val, sim_val, sim_val/ana_val) 
    244245            raise sys.exc_type, sys.exc_value 
    245246 
    … …  
    395396            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    396397        except: 
    397             print "Error", ana_val, sim_val, sim_val/ana_val 
     398            print("Error", ana_val, sim_val, sim_val/ana_val) 
    398399            raise sys.exc_type, sys.exc_value 
    399400 
    … …  
    407408            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    408409        except: 
    409             print "Error", ana_val, sim_val, sim_val/ana_val 
     410            print("Error", ana_val, sim_val, sim_val/ana_val) 
    410411            raise sys.exc_type, sys.exc_value 
    411412 
    … …  
    419420            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    420421        except: 
    421             print "Error", ana_val, sim_val, sim_val/ana_val 
     422            print("Error", ana_val, sim_val, sim_val/ana_val) 
    422423            raise sys.exc_type, sys.exc_value 
    423424 
    … …  
    431432            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    432433        except: 
    433             print "Error", ana_val, sim_val, sim_val/ana_val 
     434            print("Error", ana_val, sim_val, sim_val/ana_val) 
    434435            raise sys.exc_type, sys.exc_value 
    435436 

  • test/sasrealspace/test/utest_realspace.py

    r45dffa69 raaf5e49  
    33    @author: Mathieu Doucet / UTK 
    44""" 
     5from __future__ import print_function 
    56 
    67import unittest, math, time 
    … …  
    1516try: 
    1617    import VolumeCanvas 
    17     print "Testing local version" 
     18    print("Testing local version") 
    1819except: 
    1920    import sys 
    20     print sys.exc_value 
     21    print(sys.exc_value) 
    2122    #testing the version that is working on 
    22     print "Testing installed version" 
     23    print("Testing installed version") 
    2324    import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    2425      

  • test/utest_sasview.py

    r959eb01 raaf5e49  
    11#!/usr/bin/env python 
     2from __future__ import print_function 
     3 
    24import os 
    35import subprocess 
    … …  
    8082                    if has_failed: 
    8183                        failed += 1 
    82                         print "Result for %s (%s): FAILED" % (module_name, module_dir) 
    83                         print std_out 
     84                        print("Result for %s (%s): FAILED" % (module_name, module_dir)) 
     85                        print(std_out) 
    8486                    else: 
    8587                        passed += 1 
    86                         print "Result for %s: SUCCESS" % module_name 
     88                        print("Result for %s: SUCCESS" % module_name) 
    8789 
    88     print "\n----------------------------------------------" 
     90    print("\n----------------------------------------------") 
    8991    if n_tests == 0: 
    90         print "No tests." 
     92        print("No tests.") 
    9193    else: 
    92         print "Results by test modules:" 
    93         print "    PASSED: %d" % passed 
     94        print("Results by test modules:") 
     95        print("    PASSED: %d" % passed) 
    9496        ratio = 100.0*failed/(failed+passed) 
    95         print "    FAILED: %d    (%.0f%%)" % (failed,ratio) 
     97        print("    FAILED: %d    (%.0f%%)" % (failed,ratio)) 
    9698 
    97         print "Results by tests:" 
    98         print "    Tests run:    %d" % n_tests 
    99         print "    Tests failed: %d" % n_failures 
    100         print "    Test errors:  %d" % n_errors 
    101     print "----------------------------------------------" 
     99        print("Results by tests:") 
     100        print("    Tests run:    %d" % n_tests) 
     101        print("    Tests failed: %d" % n_failures) 
     102        print("    Test errors:  %d" % n_errors) 
     103    print("----------------------------------------------") 
    102104     
    103105    return failed 
Note: See TracChangeset for help on using the changeset viewer.