Exemple #1
0
    def runTest(self):
        propman = PropertyManager('MAR')

        propman.sample_run = 11001
        propman.load_monitors_with_workspace = True

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        ws = PropertyManager.sample_run.get_workspace()

        self.assertTrue(isinstance(ws, Workspace))
        self.assertEqual(ws.getNumberHistograms(), 922)

        DeleteWorkspace(ws)

        propman.load_monitors_with_workspace = False
        propman.sample_run = 11001
        ws = PropertyManager.sample_run.get_workspace()
        mon_ws = PropertyManager.sample_run.get_monitors_ws()

        self.assertEqual(ws.getNumberHistograms(), 919)
        self.assertEqual(mon_ws.getNumberHistograms(), 3)

        #
        propman = PropertyManager('MAPS')
        propman.sample_run = 17186
        propman.load_monitors_with_workspace = False

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws, Workspace))
        self.assertEqual(ws.getNumberHistograms(), 41472)
        self.assertEqual(mon_ws.getNumberHistograms(), 4)

        #
        self.valid = True
    def test_descr_basic(self):
        propman = PropertyManager('MAR')

        self.assertEqual(propman.sample_run, None)
        self.assertEqual(PropertyManager.sample_run.get_workspace(), None)

        propman.sample_run = 10
        self.assertEqual(propman.sample_run, 10)

        run_ws = CreateSampleWorkspace(Function='Multiple Peaks',
                                       NumBanks=1,
                                       BankPixelWidth=4,
                                       NumEvents=100)
        propman.sample_run = 'run_ws'
        self.assertEqual(PropertyManager.sample_run.run_number(), 0)

        stor_ws = PropertyManager.sample_run.get_workspace()
        rez = CompareWorkspaces(Workspace1=run_ws, Workspace2=stor_ws)

        self.assertTrue(rez[0])

        propman.sample_run = 'MAR11001.RAW'
        self.assertFalse('run_ws' in mtd)
        self.assertEqual(PropertyManager.sample_run.run_number(), 11001)
        self.assertEqual(PropertyManager.sample_run._fext, '.RAW')
    def test_get_run_list(self):
        propman = PropertyManager('MAR')
        propman.sample_run = [10204]

        self.assertEqual(propman.sample_run,10204)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),1)
        self.assertEqual(runs[0],10204)

        propman.sample_run = [11230,10382,10009]
        self.assertEqual(propman.sample_run,11230)
        propman.sum_runs = True
        propman.sample_run = [11231,10382,10010]
        self.assertEqual(propman.sample_run,10010)

        sum_list = PropertyManager.sum_runs.get_run_list2sum()
        self.assertEqual(len(sum_list),3)

        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(runs[0],sum_list[0])

        propman.sample_run = 11231
        sum_list = PropertyManager.sum_runs.get_run_list2sum()
        self.assertEqual(len(sum_list),1)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(propman.sample_run,11231)

        propman.sample_run = 10382
        sum_list = PropertyManager.sum_runs.get_run_list2sum()
        self.assertEqual(len(sum_list),2)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(sum_list[1],10382)
        self.assertEqual(propman.sample_run,10382)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),3)

        propman.sample_run = 10010
        sum_list = PropertyManager.sum_runs.get_run_list2sum()
        self.assertEqual(len(sum_list),3)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(sum_list[1],10382)
        self.assertEqual(sum_list[2],10010)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),3)
        self.assertTrue(propman.sum_runs)


        propman.sample_run = 10011
        sum_list = PropertyManager.sum_runs.get_run_list2sum()
        self.assertEqual(len(sum_list),0)

        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),1)
        self.assertEqual(runs[0],10011)
        self.assertFalse(propman.sum_runs)
    def test_set_defailts_from_instrument(self):
        ws = CreateSampleWorkspace(NumBanks=1, BankPixelWidth=4, NumEvents=100)

        SetInstrumentParameter(ws,
                               ParameterName="TestParam1",
                               Value="3.5",
                               ParameterType="Number")
        SetInstrumentParameter(ws,
                               ParameterName="TestParam2",
                               Value="initial1",
                               ParameterType="String")
        SetInstrumentParameter(ws,
                               ParameterName="TestParam3",
                               Value="initial2",
                               ParameterType="String")

        instr = ws.getInstrument()
        propman = PropertyManager(instr)

        self.assertAlmostEqual(propman.TestParam1, 3.5)
        self.assertEquals(propman.TestParam2, "initial1")
        self.assertEquals(propman.TestParam3, "initial2")

        propman.TestParam2 = "gui_changed1"
        self.assertEquals(propman.TestParam2, "gui_changed1")

        SetInstrumentParameter(ws,
                               ParameterName="TestParam2",
                               Value="instr_changed1",
                               ParameterType="String")
        SetInstrumentParameter(ws,
                               ParameterName="TestParam3",
                               Value="instr_changed2",
                               ParameterType="String")

        self.assertAlmostEqual(propman.TestParam1, 3.5)
        self.assertEquals(propman.TestParam2, "gui_changed1")
        self.assertEquals(propman.TestParam3, "initial2")
        changes = propman.getChangedProperties()
        self.assertTrue('TestParam2' in changes)
        self.assertTrue(not ('TestParam3' in changes))

        changes = propman.update_defaults_from_instrument(ws.getInstrument())

        self.assertAlmostEqual(propman.TestParam1, 3.5)
        self.assertEquals(propman.TestParam2, "gui_changed1")
        self.assertEquals(propman.TestParam3, "instr_changed2")

        self.assertTrue('TestParam2' in changes)
        self.assertTrue('TestParam3' in changes)
    def test_set_non_default_complex_value_synonims(self):
        propman = PropertyManager("MAP")
        propman.test_ei2_mon_spectra = 10000
        self.assertEqual(propman.ei_mon_spectra, [41474, 10000])

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed), 1)

        self.assertTrue(
            "ei-mon2-spec" in prop_changed,
            "changing test_ei2_mon_spectra should change ei-mon2-spectra")

        propman.test_mon_spectra_composite = [10000, 2000]
        self.assertEqual(propman.ei_mon_spectra, [10000, 2000])

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed), 2)

        self.assertTrue(
            "ei_mon_spectra" in prop_changed,
            "changing test_mon_spectra_composite should change ei_mon_spectra")

        ## HOW TO MAKE IT WORK? it fails silently
        propman.ei_mon_spectra[1] = 100
        self.assertEqual(10000, propman.ei_mon_spectra[0])
        self.assertEqual(2000, propman.ei_mon_spectra[1])

        propman.ei_mon_spectra = [100, 200]
        self.assertEqual(100, propman.ei_mon_spectra[0])
        self.assertEqual(200, propman.ei_mon_spectra[1])
Exemple #6
0
    def test_set_non_default_complex_value_synonims(self):
        propman = PropertyManager("MAP")
        propman.test_ei2_mon_spectra = 10000
        self.assertEqual(propman.ei_mon_spectra,(41475,10000))

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed),1)

        self.assertTrue("ei-mon2-spec" in prop_changed,"changing test_ei2_mon_spectra should change ei-mon2-spectra")


        propman.test_mon_spectra_composite = [10000,2000]
        self.assertEqual(propman.ei_mon_spectra,(10000,2000))

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed),2)

        self.assertTrue("ei_mon_spectra" in prop_changed,"changing test_mon_spectra_composite should change ei_mon_spectra")

        ## weird way to prohibit this assignment
        # But it works and I was not able to find any other way!
        try:
            propman.ei_mon_spectra[1] = 100
            Success=True
        except TypeError:
            Success=False
        self.assertFalse(Success)
        self.assertEqual(10000,propman.ei_mon_spectra[0])
        self.assertEqual(2000,propman.ei_mon_spectra[1])

        # This works as should
        propman.ei_mon_spectra = (100,200)
        self.assertEqual(100,propman.ei_mon_spectra[0])
        self.assertEqual(200,propman.ei_mon_spectra[1])
    def runTest(self):
        propman = PropertyManager('MAR')

        propman.sample_run = 11001
        propman.load_monitors_with_workspace = True

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        ws = PropertyManager.sample_run.get_workspace()

        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),922)

        DeleteWorkspace(ws)

        propman.load_monitors_with_workspace = False
        propman.sample_run = 11001
        ws = PropertyManager.sample_run.get_workspace()
        mon_ws = PropertyManager.sample_run.get_monitors_ws()

        self.assertEqual(ws.getNumberHistograms(),919)
        self.assertEqual(mon_ws.getNumberHistograms(),3)

        #
        propman = PropertyManager('MAPS')
        propman.sample_run = 17186
        propman.load_monitors_with_workspace = False

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),41472)
        self.assertEqual(mon_ws.getNumberHistograms(),4)

        #
        self.valid = True
    def test_descr_basic(self):
        propman  = PropertyManager('MAR')

        self.assertTrue(propman.sample_run is None)
        self.assertTrue(PropertyManager.sample_run.get_workspace() is None)
        
        propman.sample_run = 10;
        self.assertEqual(propman.sample_run,10)

        run_ws = CreateSampleWorkspace( Function='Multiple Peaks', NumBanks=1, BankPixelWidth=4, NumEvents=100)
        propman.sample_run = 'run_ws'
        self.assertEqual(PropertyManager.sample_run.run_number(),0)

        stor_ws = PropertyManager.sample_run.get_workspace()
        rez = CheckWorkspacesMatch(Workspace1=run_ws,Workspace2=stor_ws)

        self.assertEqual(rez,'Success!')
    def test_set_non_default_complex_value_synonims(self):
        propman = PropertyManager("MAP")
        propman.test_ei2_mon_spectra = 10000
        self.assertEqual(propman.ei_mon_spectra,[41474,10000])

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed),1)

        self.assertTrue("ei-mon2-spec" in prop_changed,"changing test_ei2_mon_spectra should change ei-mon2-spectra")


        propman.test_mon_spectra_composite = [10000,2000]        
        self.assertEqual(propman.ei_mon_spectra,[10000,2000])

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed),2)

        self.assertTrue("ei_mon_spectra" in prop_changed,"changing test_mon_spectra_composite should change ei_mon_spectra")

    ## HOW TO MAKE IT WORK? it fails silently
        propman.ei_mon_spectra[1]=100
        self.assertEqual(10000,propman.ei_mon_spectra[0])
        self.assertEqual(2000,propman.ei_mon_spectra[1])


        propman.ei_mon_spectra=[100,200]
        self.assertEqual(100,propman.ei_mon_spectra[0])
        self.assertEqual(200,propman.ei_mon_spectra[1])
    def test_set_non_default_complex_value_synonims(self):
        propman = PropertyManager("MAP")
        propman.test_ei2_mon_spectra = 10000
        self.assertEqual(propman.ei_mon_spectra,(41475,10000))

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed),1)

        self.assertTrue("ei-mon2-spec" in prop_changed,"changing test_ei2_mon_spectra should change ei-mon2-spectra")


        propman.test_mon_spectra_composite = [10000,2000]
        self.assertEqual(propman.ei_mon_spectra,(10000,2000))

        prop_changed = propman.getChangedProperties()
        self.assertEqual(len(prop_changed),2)

        self.assertTrue("ei_mon_spectra" in prop_changed,"changing test_mon_spectra_composite should change ei_mon_spectra")

        ## weird way to prohibit this assignment
        # But it works and I was not able to find any other way!
        try:
            propman.ei_mon_spectra[1] = 100
            Success=True
        except TypeError:
            Success=False
        self.assertFalse(Success)
        self.assertEqual(10000,propman.ei_mon_spectra[0])
        self.assertEqual(2000,propman.ei_mon_spectra[1])

        # This works as should
        propman.ei_mon_spectra = (100,200)
        self.assertEqual(100,propman.ei_mon_spectra[0])
        self.assertEqual(200,propman.ei_mon_spectra[1])
Exemple #11
0
    def test_set_complex_defaults_from_instrument(self) :
        ws = CreateSampleWorkspace(NumBanks=1, BankPixelWidth=4, NumEvents=10)

        SetInstrumentParameter(ws,ParameterName="Param1",Value="BaseParam1:BaseParam2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam1",Value="Val1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam2",Value="Val2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="synonims",Value="ParaPara=BaseParam2",ParameterType="String")

        instr = ws.getInstrument()
        propman = PropertyManager(instr)

        SampleResult = ['Val1','Val2']
        cVal = propman.Param1
        for test,sample in zip(cVal,SampleResult):
            self.assertEqual(test,sample)

        self.assertEqual(propman.ParaPara,'Val2')
        self.assertEqual(propman.BaseParam2,'Val2')

        propman.sample_run = ws
        # assume we get workspace with different instrument parameters
        SetInstrumentParameter(ws,ParameterName="Param1",Value="addParam1:addParam2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam1",Value="OtherVal1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam2",Value="OtherVal2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="addParam1",Value="Ignore1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="addParam2",Value="Ignore2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="mask_run",Value="None",ParameterType="String")

        old_changes = propman.getChangedProperties()

        changed_prop = propman.update_defaults_from_instrument(ws.getInstrument())

        self.assertEqual(len(changed_prop),4)
        #property have been changed from GUI and changes from instrument are
        #ignored
        SampleResult = ['OtherVal1','OtherVal2']
        cVal = propman.Param1
        for test,sample in zip(cVal,SampleResult):
            self.assertEqual(test,sample)

        self.assertEqual(propman.ParaPara,'OtherVal2')
        self.assertEqual(propman.BaseParam2,'OtherVal2')

        self.assertEqual(propman.BaseParam1,"OtherVal1")
    def test_set_complex_defailts_from_instrument(self) :
        ws = CreateSampleWorkspace(NumBanks=1, BankPixelWidth=4, NumEvents=10)

        SetInstrumentParameter(ws,ParameterName="Param1",Value="BaseParam1:BaseParam2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam1",Value="Val1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam2",Value="Val2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="synonims",Value="ParaPara=BaseParam2",ParameterType="String")

        instr = ws.getInstrument()
        propman = PropertyManager(instr)

        SampleResult = ['Val1','Val2']
        cVal = propman.Param1
        for test,sample in zip(cVal,SampleResult):
            self.assertEqual(test,sample)

        self.assertEqual(propman.ParaPara,'Val2')
        self.assertEqual(propman.BaseParam2,'Val2')

        propman.sample_run = ws
        # assume we get workspace with different instrument parameters
        SetInstrumentParameter(ws,ParameterName="Param1",Value="addParam1:addParam2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam1",Value="OtherVal1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="BaseParam2",Value="OtherVal2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="addParam1",Value="Ignore1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="addParam2",Value="Ignore2",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="mask_run",Value="None",ParameterType="String")

        old_changes = propman.getChangedProperties()

        changed_prop = propman.update_defaults_from_instrument(ws.getInstrument())

        self.assertEqual(len(changed_prop),4)
        #property have been changed from GUI and changes from instrument are
        #ignored
        SampleResult = ['OtherVal1','OtherVal2']
        cVal = propman.Param1
        for test,sample in zip(cVal,SampleResult):
            self.assertEqual(test,sample)

        self.assertEqual(propman.ParaPara,'OtherVal2')
        self.assertEqual(propman.BaseParam2,'OtherVal2')

        self.assertEqual(propman.BaseParam1,"OtherVal1")
    def test_descr_basic(self):
        propman = PropertyManager('MAR')

        self.assertTrue(propman.sample_run is None)
        self.assertTrue(PropertyManager.sample_run.get_workspace() is None)

        propman.sample_run = 10
        self.assertEqual(propman.sample_run, 10)

        run_ws = CreateSampleWorkspace(Function='Multiple Peaks',
                                       NumBanks=1,
                                       BankPixelWidth=4,
                                       NumEvents=100)
        propman.sample_run = 'run_ws'
        self.assertEqual(PropertyManager.sample_run.run_number(), 0)

        stor_ws = PropertyManager.sample_run.get_workspace()
        rez = CheckWorkspacesMatch(Workspace1=run_ws, Workspace2=stor_ws)

        self.assertEqual(rez, 'Success!')
    def runTest(self):

        # 
        propman = PropertyManager('LET')


        propman.sample_run = 6278 #event nexus file
        propman.load_monitors_with_workspace = False

        # Here we have known problem of propman loading new IDF, and
        # workspace is written using old IDF. New IDF has mon1_norm_spec =73729
        # and ei_mon1_spec=73734   (on January 2015) and old 
        # IDF -- mon1_norm_spec =40961 and 40966 (forever) 
        # Normalized by monitor-1. -- need monitor1 and ei needs ei_mon1_spec
        # This problem is hopefully fixed in reduction now, but here 
        # we have to specify these values manually to guard against 
        # changes in a future
        propman.normalise_method='monitor-1'
        propman.mon1_norm_spec=40961
        propman.ei_mon1_spec  =40966

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(not(mon_ws is None))
        ws = PropertyManager.sample_run.get_workspace()

        self.assertTrue(isinstance(ws,IEventWorkspace))
        self.assertEqual(ws.getNumberHistograms(),40960)
        self.assertTrue(isinstance(mon_ws,Workspace))
        # 
        self.assertEqual(mon_ws.getNumberHistograms(),9)


        self.valid = True
    def test_descr_basic(self):
        propman  = PropertyManager('MAR')

        self.assertTrue(propman.sample_run is None)
        self.assertTrue(PropertyManager.sample_run.get_workspace() is None)

        propman.sample_run = 10
        self.assertEqual(propman.sample_run,10)

        run_ws = CreateSampleWorkspace( Function='Multiple Peaks', NumBanks=1, BankPixelWidth=4, NumEvents=100)
        propman.sample_run = 'run_ws'
        self.assertEqual(PropertyManager.sample_run.run_number(),0)

        stor_ws = PropertyManager.sample_run.get_workspace()
        rez = CompareWorkspaces(Workspace1=run_ws,Workspace2=stor_ws)

        self.assertTrue(rez[0])

        propman.sample_run='MAR11001.RAW'
        self.assertFalse('run_ws' in mtd)
        self.assertEqual(PropertyManager.sample_run.run_number(),11001)
        self.assertEqual(PropertyManager.sample_run._fext,'.RAW')
Exemple #16
0
    def runTest(self):

        #
        propman = PropertyManager('LET')


        propman.sample_run = 6278 #event nexus file
        propman.load_monitors_with_workspace = False

        # Here we have known problem of propman loading new IDF, and
        # workspace is written using old IDF. New IDF has mon1_norm_spec =73729
        # and ei_mon1_spec=73734   (on January 2015) and old
        # IDF -- mon1_norm_spec =40961 and 40966 (forever)
        # Normalized by monitor-1. -- need monitor1 and ei needs ei_mon1_spec
        # This problem is hopefully fixed in reduction now, but here
        # we have to specify these values manually to guard against
        # changes in a future. This issue should be now fixed through varions means
        propman.normalise_method='monitor-1'
        # Adjust old IDF to new changes. This may change when loader is modified.
        propman.ei_mon2_spec  = [5506,5505,5507]
        propman.spectra_to_monitors_list=[5506,5505,5507]
        #
        ws = PropertyManager.sample_run.get_workspace()
        # apply IDF property, correspondent to this particular time interval
        propman.update_defaults_from_instrument(ws.getInstrument())
        self.assertEqual(int(propman.mon1_norm_spec),40961)
        self.assertEqual(propman.ei_mon1_spec,40966)


        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(not mon_ws is None)

        self.assertTrue(isinstance(ws,IEventWorkspace))
        self.assertEqual(ws.getNumberHistograms(),40960)
        self.assertTrue(isinstance(mon_ws,Workspace))
        #
        self.assertEqual(mon_ws.getNumberHistograms(),11)

        ei_ws = GetAllEi(mon_ws,40966,40967,IgnoreSecondMonitor=True)
        self.assertTrue(isinstance(ei_ws,Workspace))

        self.valid = True
    def test_set_defailts_from_instrument(self) :
        ws = CreateSampleWorkspace(NumBanks=1, BankPixelWidth=4, NumEvents=100)

        SetInstrumentParameter(ws,ParameterName="TestParam1",Value="3.5",ParameterType="Number")
        SetInstrumentParameter(ws,ParameterName="TestParam2",Value="initial1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="TestParam3",Value="initial2",ParameterType="String")

        instr = ws.getInstrument()
        propman = PropertyManager(instr)

        self.assertAlmostEqual(propman.TestParam1,3.5)
        self.assertEqual(propman.TestParam2,"initial1")
        self.assertEqual(propman.TestParam3,"initial2")

        propman.TestParam2 = "gui_changed1"
        self.assertEqual(propman.TestParam2,"gui_changed1")

        SetInstrumentParameter(ws,ParameterName="TestParam2",Value="instr_changed1",ParameterType="String")
        SetInstrumentParameter(ws,ParameterName="TestParam3",Value="instr_changed2",ParameterType="String")

        self.assertAlmostEqual(propman.TestParam1,3.5)
        self.assertEqual(propman.TestParam2,"gui_changed1")
        self.assertEqual(propman.TestParam3,"initial2")
        changes = propman.getChangedProperties()
        self.assertTrue('TestParam2' in changes)
        self.assertTrue(not('TestParam3' in changes))



        changes = propman.update_defaults_from_instrument(ws.getInstrument())

        self.assertAlmostEqual(propman.TestParam1,3.5)
        self.assertEqual(propman.TestParam2,"gui_changed1")
        self.assertEqual(propman.TestParam3,"instr_changed2")

        self.assertTrue('TestParam2' in changes)
        self.assertTrue('TestParam3' in changes)
    def test_diag_spectra(self):
        propman = self.prop_man

        self.assertTrue(propman.diag_spectra is None)

        propman.diag_spectra = '(19,299);(399,500)'
        spectra = propman.diag_spectra
        self.assertEqual(spectra[0], (19, 299))
        self.assertEqual(spectra[1], (399, 500))

        propman = PropertyManager("MAP")
        spectra = propman.diag_spectra
        # (1,17280);(17281,18432);(18433,32256);(32257,41472)
        self.assertEqual(len(spectra), 4)
        self.assertEqual(spectra[0], (1, 17280))
        self.assertEqual(spectra[3], (32257, 41472))
    def test_get_run_list(self):
        """ verify the logic behind setting a run file as
            a sample run when run list is defined
        """
        propman = PropertyManager('MAR')
        propman.sample_run = [10204]

        self.assertEqual(propman.sample_run, 10204)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs), 1)
        self.assertEqual(runs[0], 10204)
        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list), 0)
        self.assertEqual(sum_ws, None)
        self.assertEqual(n_sum, 0)

        # the same run list changes nothing
        propman.sample_run = [10204]
        self.assertEqual(propman.sample_run, 10204)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs), 1)
        self.assertEqual(runs[0], 10204)

        propman.sample_run = [11230, 10382, 10009]
        self.assertEqual(propman.sample_run, 11230)

        propman.sum_runs = True
        self.assertEqual(propman.sample_run, 10009)
        propman.sample_run = [11231, 10382, 10010]
        self.assertEqual(propman.sample_run, 10010)

        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list), 3)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(runs[0], sum_list[0])

        # Autoreduction workflow with summation. Runs appear
        # one by one and summed together when next run appears
        propman.sample_run = 11231
        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()

        self.assertEqual(len(sum_list), 1)
        self.assertEqual(sum_list[0], 11231)
        self.assertEqual(propman.sample_run, 11231)

        propman.sample_run = 10382
        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list), 2)
        self.assertEqual(sum_list[0], 11231)
        self.assertEqual(sum_list[1], 10382)
        self.assertEqual(propman.sample_run, 10382)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs), 3)

        propman.sample_run = 10010
        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list), 3)
        self.assertEqual(sum_list[0], 11231)
        self.assertEqual(sum_list[1], 10382)
        self.assertEqual(sum_list[2], 10010)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs), 3)
        self.assertTrue(propman.sum_runs)

        # check asigning file with path
        propman.sample_run = 'c:/data/MAR10382.nxs'
        self.assertEqual(propman.sample_run, 10382)
        self.assertEqual(PropertyManager.sample_run._run_list._last_ind2sum, 1)
        self.assertEqual(PropertyManager.sample_run._run_list._file_path[1],
                         'c:/data')
        self.assertEqual(PropertyManager.sample_run._run_list._fext[1], '.nxs')

        # check extend when summing
        propman.sample_run = 10999
        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list), 4)
        self.assertEqual(sum_list[0], 11231)
        self.assertEqual(sum_list[1], 10382)
        self.assertEqual(sum_list[2], 10010)
        self.assertEqual(sum_list[3], 10999)
        self.assertTrue(propman.sum_runs)

        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs), 4)
        self.assertTrue(propman.sum_runs)

        propman.sum_runs = False
        run_list = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(run_list), 4)
        self.assertEqual(propman.sample_run, 11231)
        sum_list, sum_ws, n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list), 0)

        # check clear list when not summing
        propman.sample_run = 11999
        run_list = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(run_list), 1)

        # check if run list can be set up using range
        propman.sample_run = range(1, 4)
        run_list = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(run_list), 3)
        self.assertTrue(isinstance(run_list, list))
 def setUp(self):
     if self.prop_man is None or type(
             self.prop_man) != type(PropertyManager):
         self.prop_man = PropertyManager("MAR")
 def __init__(self, methodName):
     self.prop_man = PropertyManager("MAR")
     return super(RunDescriptorTest, self).__init__(methodName)
Exemple #22
0
    def test_get_run_list(self):
        """ verify the logic behind setting a run file as 
            a sample run when run list is defined
            
        """ 
        propman = PropertyManager('MAR')
        propman.sample_run = [10204]

        self.assertEqual(propman.sample_run,10204)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),1)
        self.assertEqual(runs[0],10204)
        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list),0)
        self.assertTrue(sum_ws is None)
        self.assertEqual(n_sum,0)


        # the same run list changes nothing
        propman.sample_run = [10204]
        self.assertEqual(propman.sample_run,10204)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),1)
        self.assertEqual(runs[0],10204)


        propman.sample_run = [11230,10382,10009]
        self.assertEqual(propman.sample_run,11230)


        propman.sum_runs = True
        self.assertEqual(propman.sample_run,10009)
        propman.sample_run = [11231,10382,10010]
        self.assertEqual(propman.sample_run,10010)

        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list),3)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(runs[0],sum_list[0])

        # Autoreduction workflow with summation. Runs appear
        # one by one and summed together when next run appears
        propman.sample_run = 11231
        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()

        self.assertEqual(len(sum_list),1)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(propman.sample_run,11231)

        propman.sample_run = 10382
        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list),2)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(sum_list[1],10382)
        self.assertEqual(propman.sample_run,10382)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),3)

        propman.sample_run = 10010
        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list),3)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(sum_list[1],10382)
        self.assertEqual(sum_list[2],10010)
        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),3)
        self.assertTrue(propman.sum_runs)

        # check asigning file with path
        propman.sample_run = 'c:/data/MAR10382.nxs'
        self.assertEqual(propman.sample_run,10382)
        self.assertEqual(PropertyManager.sample_run._run_list._last_ind2sum,1)
        self.assertEqual(PropertyManager.sample_run._run_list._file_path[1],'c:/data')
        self.assertEqual(PropertyManager.sample_run._run_list._fext[1],'.nxs')


        # check extend when summing
        propman.sample_run = 10999
        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list),4)
        self.assertEqual(sum_list[0],11231)
        self.assertEqual(sum_list[1],10382)
        self.assertEqual(sum_list[2],10010)
        self.assertEqual(sum_list[3],10999)
        self.assertTrue(propman.sum_runs)

        runs = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(runs),4)
        self.assertTrue(propman.sum_runs)


        propman.sum_runs=False
        run_list = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(run_list),4)
        self.assertEqual(propman.sample_run,11231)
        sum_list,sum_ws,n_sum = PropertyManager.sample_run.get_runs_to_sum()
        self.assertEqual(len(sum_list),0)

        # check clear list when not summing 
        propman.sample_run = 11999
        run_list = PropertyManager.sample_run.get_run_list()
        self.assertEqual(len(run_list),1)
    def runTest(self):
        #
        propman = PropertyManager('MER')
        propman.sample_run = 6398 # (raw file)
        propman.det_cal_file = 6399 
        propman.load_monitors_with_workspace = False

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(not(mon_ws is None))

        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69632)
        self.assertEqual(mon_ws.getNumberHistograms(),9)

        # test load together
        propman.sample_run = None # (clean things up)
        propman.load_monitors_with_workspace = True
        propman.sample_run  = 6398

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(not(mon_ws is None))
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69641)
        self.assertEqual(mon_ws.getNumberHistograms(),69641)


        propman.sample_run = 18492 # (histogram nxs file )
        propman.det_cal_file = None 
        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(not(mon_ws is None))
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69641)
        self.assertEqual(mon_ws.getNumberHistograms(),69641)


        self.valid = True
        return
        #  enable when bug #10980 is fixed
        propman.sample_run = 18492 # (histogram nxs file )
        propman.det_cal_file = None 
        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(not(mon_ws is None))

        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69632)
        self.assertEqual(mon_ws.getNumberHistograms(),9)


        self.valid = True
    def runTest(self):
        #
        propman = PropertyManager('MER')
        propman.sample_run = 6398 # (raw file)
        propman.det_cal_file = 6399
        propman.load_monitors_with_workspace = False

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(mon_ws is not None)

        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69632)
        self.assertEqual(mon_ws.getNumberHistograms(),9)

        # test load together
        propman.sample_run = None # (clean things up)
        propman.load_monitors_with_workspace = True
        propman.sample_run  = 6398

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(mon_ws is not None)
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69641)
        self.assertEqual(mon_ws.getNumberHistograms(),69641)

        propman.sample_run = 18492 # (histogram nxs file )
        propman.det_cal_file = None
        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue('SR_MER018492' in mtd)
        self.assertTrue(mon_ws is not None)
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69641)
        self.assertEqual(mon_ws.getNumberHistograms(),69641)
        self.assertEqual(mon_ws.getIndexFromSpectrumNumber(69638),69637)
        det = mon_ws.getDetector(69632)
        self.assertTrue(det.isMonitor())
        det = mon_ws.getDetector(69631)
        self.assertFalse(det.isMonitor())

        #  enable when bug #10980 is fixed
        propman.sample_run = None # delete all
        self.assertFalse('SR_MER018492' in mtd)
        propman.sample_run = 18492 # (histogram nxs file )
        propman.load_monitors_with_workspace = False
        propman.det_cal_file = None
        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(mon_ws is not None)
        self.assertTrue('SR_MER018492_monitors' in mtd)

        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws,Workspace))
        self.assertEqual(ws.getNumberHistograms(),69632)
        self.assertEqual(mon_ws.getNumberHistograms(),9)
        self.assertEqual(mon_ws.getIndexFromSpectrumNumber(69633),0)
        det = mon_ws.getDetector(0)
        self.assertTrue(det.isMonitor())

        ei_ws = GetAllEi(mon_ws,69634,69638,IgnoreSecondMonitor=False)
        self.assertTrue(isinstance(ei_ws,Workspace))

        en_peaks = ei_ws.readX(0)
        self.assertAlmostEquals(len(en_peaks),1)
        self.assertAlmostEqual(en_peaks[0],108.94,2)

        self.valid = True
Exemple #25
0
    def runTest(self):
        #
        propman = PropertyManager('MER')
        propman.sample_run = 6398  # (raw file)
        propman.det_cal_file = 6399
        propman.load_monitors_with_workspace = False

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(mon_ws is not None)

        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws, Workspace))
        self.assertEqual(ws.getNumberHistograms(), 69632)
        self.assertEqual(mon_ws.getNumberHistograms(), 9)

        # test load together
        propman.sample_run = None  # (clean things up)
        propman.load_monitors_with_workspace = True
        propman.sample_run = 6398

        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(mon_ws is not None)
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws, Workspace))
        self.assertEqual(ws.getNumberHistograms(), 69641)
        self.assertEqual(mon_ws.getNumberHistograms(), 69641)

        propman.sample_run = 18492  # (histogram nxs file )
        propman.det_cal_file = None
        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue('SR_MER018492' in mtd)
        self.assertTrue(mon_ws is not None)
        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws, Workspace))
        self.assertEqual(ws.getNumberHistograms(), 69641)
        self.assertEqual(mon_ws.getNumberHistograms(), 69641)
        self.assertEqual(mon_ws.getIndexFromSpectrumNumber(69638), 69637)
        det = mon_ws.getDetector(69632)
        self.assertTrue(det.isMonitor())
        det = mon_ws.getDetector(69631)
        self.assertFalse(det.isMonitor())

        #  enable when bug #10980 is fixed
        propman.sample_run = None  # delete all
        self.assertFalse('SR_MER018492' in mtd)
        propman.sample_run = 18492  # (histogram nxs file )
        propman.load_monitors_with_workspace = False
        propman.det_cal_file = None
        mon_ws = PropertyManager.sample_run.get_monitors_ws()
        self.assertTrue(mon_ws is not None)
        self.assertTrue('SR_MER018492_monitors' in mtd)

        ws = PropertyManager.sample_run.get_workspace()
        self.assertTrue(isinstance(ws, Workspace))
        self.assertEqual(ws.getNumberHistograms(), 69632)
        self.assertEqual(mon_ws.getNumberHistograms(), 9)
        self.assertEqual(mon_ws.getIndexFromSpectrumNumber(69633), 0)
        det = mon_ws.getDetector(0)
        self.assertTrue(det.isMonitor())

        ei_ws = GetAllEi(mon_ws, 69634, 69638, IgnoreSecondMonitor=False)
        self.assertTrue(isinstance(ei_ws, Workspace))

        en_peaks = ei_ws.readX(0)
        self.assertAlmostEquals(len(en_peaks), 1)
        self.assertAlmostEqual(en_peaks[0], 108.94, 2)

        self.valid = True
 def __init__(self, methodName):
     self.prop_man = PropertyManager("MAR")
     return super(DirectPropertyManagerTest, self).__init__(methodName)