Пример #1
0
	def PyExec(self):
		run_f2py_compatibility_test()
		
		self.log().information('Jump input')
		inType = self.getPropertyValue('InputType')
		prefix = self.getPropertyValue('Instrument')
		ana = self.getPropertyValue('Analyser')
		prog = self.getPropertyValue('QLprogram')
		jump = self.getPropertyValue('Fit')
		fw = self.getPropertyValue('Width')
		sam = self.getPropertyValue('SamNumber')

		sname = prefix+sam+'_'+ana+'_'+prog
		cropOp = self.getProperty('CropQ')
		if cropOp:
			qmin = self.getPropertyValue('Qmin')
			qmax = self.getPropertyValue('Qmax')
			qrange = [qmin, qmax]
		else:
			qrange = [0.0, 5.0]
		verbOp = self.getProperty('Verbose')
		plotOp = self.getProperty('Plot')
		saveOp = self.getProperty('Save')

		workdir = config['defaultsave.directory']
		if inType == 'File':
			path = os.path.join(workdir, sname+'_Parameters.nxs')					# path name for nxs file
			LoadNexusProcessed(Filename=path, OutputWorkspace=sname+'_Parameters')
			message = 'Input from File : '+path
		else:
			message = 'Input from Workspace : '+sname
		if verbOp:
			logger.notice(message)
		Main.JumpRun(sname,jump,prog,fw,cropOp,qrange,verbOp,plotOp,saveOp)
Пример #2
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectMuscat as Main

        run_f2py_compatibility_test()

        self.log().information('Muscat input')
        prefix = self.getPropertyValue('Instrument')
        ana = self.getPropertyValue('Analyser')
        geom = self.getPropertyValue('Geom')
        disp = self.getPropertyValue('Dispersion')
        sam = self.getPropertyValue('SamNumber')
        sname = prefix + sam + '_' + ana

        NRUN1 = self.getPropertyValue('NR1')
        NRUN2 = self.getPropertyValue('NR2')
        NMST = self.getPropertyValue('Nms')
        JRAND = 12345
        MRAND = 67890
        neut = [int(NRUN1), int(NRUN2), int(JRAND), int(MRAND), int(NMST)]

        HEIGHT = 3.0
        alfa = self.getPropertyValue('DetAngle')
        THICK = self.getPropertyValue('Thick')
        WIDTH = self.getPropertyValue('Width')
        HEIGHT = self.getPropertyValue('Height')
        if geom == 'Flat':
            beam = [float(THICK), float(WIDTH), float(HEIGHT), float(alfa)]
        if geom == 'Cyl':
            beam = [float(THICK),
                    float(WIDTH),
                    float(HEIGHT), 0.0]  #beam = [WIDTH, WIDTH2, HEIGHT, 0.0]
        dens = self.getPropertyValue('Density')
        sigb = self.getPropertyValue('SigScat')
        siga = self.getPropertyValue('SigAbs')
        sigss = sigb
        temp = self.getPropertyValue('Temperature')
        sam = [float(temp), float(dens), float(siga), float(sigb)]

        NQ = self.getPropertyValue('NQ')
        dQ = self.getPropertyValue('dQ')
        Nw = self.getPropertyValue('NW')
        dw = self.getPropertyValue('dW')  #in microeV
        grid = [int(NQ), float(dQ), int(Nw), float(dw)]
        c1 = self.getPropertyValue('Coeff1')
        c2 = self.getPropertyValue('Coeff2')
        c3 = self.getPropertyValue('Coeff3')
        c4 = self.getPropertyValue('Coeff4')
        c5 = self.getPropertyValue('Coeff5')
        coeff = [float(c1), float(c2), float(c3), float(c4), float(c5)]
        kr1 = 1

        verbOp = self.getProperty('Verbose').value
        plotOp = self.getPropertyValue('Plot')
        saveOp = self.getProperty('Save').value
        Main.MuscatFuncStart(sname, geom, neut, beam, sam, grid, disp, coeff,
                             kr1, verbOp, plotOp, saveOp)
Пример #3
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectBayes as Main

        run_f2py_compatibility_test()

        self.log().information('Quest input')
        inType = self.getPropertyValue('InputType')
        prefix = self.getPropertyValue('Instrument')
        ana = self.getPropertyValue('Analyser')
        sam = self.getPropertyValue('SamNumber')
        rinType = self.getPropertyValue('ResInputType')
        res = self.getPropertyValue('ResNumber')
        elastic = self.getProperty('ElasticOption').value
        bgd = self.getPropertyValue('BackgroundOption')
        emin = self.getPropertyValue('EnergyMin')
        emax = self.getPropertyValue('EnergyMax')
        nbin = self.getPropertyValue('SamBinning')
        nbins = [nbin, 1]
        nbet = self.getProperty('NumberBeta').value
        nsig = self.getProperty('NumberSigma').value
        nbs = [nbet, nsig]

        sname = prefix+sam+'_'+ana + '_red'
        rname = prefix+res+'_'+ana + '_res'
        erange = [float(emin), float(emax)]
        if elastic:
            o_el = 1
        else:
            o_el = 0
        fitOp = [o_el, bgd, 0, 0]
        loopOp = self.getProperty('Sequence').value
        verbOp = self.getProperty('Verbose').value
        plotOp = self.getPropertyValue('Plot')
        saveOp = self.getProperty('Save').value

        workdir = config['defaultsave.directory']
        if inType == 'File':
            spath = os.path.join(workdir, sname+'.nxs')        # path name for sample nxs file
            LoadNexusProcessed(Filename=spath, OutputWorkspace=sname)
            Smessage = 'Sample from File : '+spath
        else:
            Smessage = 'Sample from Workspace : '+sname

        if rinType == 'File':
            rpath = os.path.join(workdir, rname+'.nxs')        # path name for res nxs file
            LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
            Rmessage = 'Resolution from File : '+rpath
        else:
            Rmessage = 'Resolution from Workspace : '+rname

        if verbOp:
            logger.notice(Smessage)
            logger.notice(Rmessage)
        Main.QuestRun(sname,rname,nbs,erange,nbins,fitOp,loopOp,plotOp,saveOp)
Пример #4
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectBayes as Main

        run_f2py_compatibility_test()

        self.log().information('Quest input')
        inType = self.getPropertyValue('InputType')
        prefix = self.getPropertyValue('Instrument')
        ana = self.getPropertyValue('Analyser')
        sam = self.getPropertyValue('SamNumber')
        rinType = self.getPropertyValue('ResInputType')
        res = self.getPropertyValue('ResNumber')
        elastic = self.getProperty('ElasticOption').value
        bgd = self.getPropertyValue('BackgroundOption')
        emin = self.getPropertyValue('EnergyMin')
        emax = self.getPropertyValue('EnergyMax')
        nbin = self.getPropertyValue('SamBinning')
        nbins = [nbin, 1]
        nbet = self.getProperty('NumberBeta').value
        nsig = self.getProperty('NumberSigma').value
        nbs = [nbet, nsig]

        sname = prefix+sam+'_'+ana + '_red'
        rname = prefix+res+'_'+ana + '_res'
        erange = [float(emin), float(emax)]
        if elastic:
            o_el = 1
        else:
            o_el = 0
        fitOp = [o_el, bgd, 0, 0]
        loopOp = self.getProperty('Sequence').value
        verbOp = self.getProperty('Verbose').value
        plotOp = self.getPropertyValue('Plot')
        saveOp = self.getProperty('Save').value

        workdir = config['defaultsave.directory']
        if inType == 'File':
            spath = os.path.join(workdir, sname+'.nxs')        # path name for sample nxs file
            LoadNexusProcessed(Filename=spath, OutputWorkspace=sname)
            Smessage = 'Sample from File : '+spath
        else:
            Smessage = 'Sample from Workspace : '+sname

        if rinType == 'File':
            rpath = os.path.join(workdir, rname+'.nxs')        # path name for res nxs file
            LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
            Rmessage = 'Resolution from File : '+rpath
        else:
            Rmessage = 'Resolution from Workspace : '+rname

        if verbOp:
            logger.notice(Smessage)
            logger.notice(Rmessage)
        Main.QuestRun(sname,rname,nbs,erange,nbins,fitOp,loopOp,plotOp,saveOp)
Пример #5
0
    def PyExec(self):
        run_f2py_compatibility_test()

        self.log().information("Quest input")
        inType = self.getPropertyValue("InputType")
        prefix = self.getPropertyValue("Instrument")
        ana = self.getPropertyValue("Analyser")
        sam = self.getPropertyValue("SamNumber")
        rinType = self.getPropertyValue("ResInputType")
        res = self.getPropertyValue("ResNumber")
        elastic = self.getProperty("ElasticOption")
        bgd = self.getPropertyValue("BackgroundOption")
        emin = self.getPropertyValue("EnergyMin")
        emax = self.getPropertyValue("EnergyMax")
        nbin = self.getPropertyValue("SamBinning")
        nbins = [nbin, 1]
        nbet = self.getPropertyValue("NumberBeta")
        nsig = self.getPropertyValue("NumberSigma")
        nbs = [nbet, nsig]

        sname = prefix + sam + "_" + ana + "_red"
        rname = prefix + res + "_" + ana + "_res"
        erange = [float(emin), float(emax)]
        if elastic:
            o_el = 1
        else:
            o_el = 0
        if bgd == "Sloping":
            o_bgd = 2
        if bgd == "Flat":
            o_bgd = 1
        if bgd == "Zero":
            o_bgd = 0
        fitOp = [o_el, o_bgd, 0, 0]
        loopOp = self.getProperty("Sequence")
        verbOp = self.getProperty("Verbose")
        plotOp = self.getPropertyValue("Plot")
        saveOp = self.getProperty("Save")

        workdir = config["defaultsave.directory"]
        if inType == "File":
            spath = os.path.join(workdir, sname + ".nxs")  # path name for sample nxs file
            LoadNexusProcessed(Filename=spath, OutputWorkspace=sname)
            Smessage = "Sample from File : " + spath
        else:
            Smessage = "Sample from Workspace : " + sname
        if rinType == "File":
            rpath = os.path.join(workdir, rname + ".nxs")  # path name for res nxs file
            LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
            Rmessage = "Resolution from File : " + rpath
        else:
            Rmessage = "Resolution from Workspace : " + rname
        if verbOp:
            logger.notice(Smessage)
            logger.notice(Rmessage)
        Main.QuestRun(sname, rname, nbs, erange, nbins, fitOp, loopOp, verbOp, plotOp, saveOp)
Пример #6
0
	def PyExec(self):
                from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

                if is_supported_f2py_platform():
                        import IndirectMuscat as Main

		run_f2py_compatibility_test()

		self.log().information('Muscat input')
		prefix = self.getPropertyValue('Instrument')
		ana = self.getPropertyValue('Analyser')
		geom = self.getPropertyValue('Geom')
		disp = self.getPropertyValue('Dispersion')
		sam = self.getPropertyValue('SamNumber')
		sname = prefix+sam+'_'+ana

		NRUN1 = self.getPropertyValue('NR1')
		NRUN2 = self.getPropertyValue('NR2')
		NMST = self.getPropertyValue('Nms')
		JRAND = 12345
		MRAND = 67890
		neut = [int(NRUN1), int(NRUN2), int(JRAND), int(MRAND), int(NMST)]

		HEIGHT = 3.0
		alfa = self.getPropertyValue('DetAngle')
		THICK = self.getPropertyValue('Thick')
		WIDTH = self.getPropertyValue('Width')
		HEIGHT = self.getPropertyValue('Height')
		if geom == 'Flat':
			beam = [float(THICK), float(WIDTH), float(HEIGHT), float(alfa)]
		if geom == 'Cyl':
			beam = [float(THICK), float(WIDTH), float(HEIGHT), 0.0]        #beam = [WIDTH, WIDTH2, HEIGHT, 0.0]
		dens = self.getPropertyValue('Density')
		sigb = self.getPropertyValue('SigScat')
		siga = self.getPropertyValue('SigAbs')
		sigss=sigb
		temp = self.getPropertyValue('Temperature')
		sam = [float(temp), float(dens), float(siga), float(sigb)]

		NQ = self.getPropertyValue('NQ')
		dQ = self.getPropertyValue('dQ')
		Nw = self.getPropertyValue('NW')
		dw = self.getPropertyValue('dW')           #in microeV
		grid = [int(NQ), float(dQ), int(Nw), float(dw)]
		c1 = self.getPropertyValue('Coeff1')
		c2 = self.getPropertyValue('Coeff2')
		c3 = self.getPropertyValue('Coeff3')
		c4 = self.getPropertyValue('Coeff4')
		c5 = self.getPropertyValue('Coeff5')
		coeff = [float(c1), float(c2), float(c3), float(c4), float(c5)]
		kr1 = 1

		verbOp = self.getProperty('Verbose').value
		plotOp = self.getPropertyValue('Plot')
		saveOp = self.getProperty('Save').value
		Main.MuscatFuncStart(sname,geom,neut,beam,sam,grid,disp,coeff,kr1,verbOp,plotOp,saveOp)
Пример #7
0
	def PyExec(self):
		run_f2py_compatibility_test()
		
		self.log().information('ILLines input')
		inType = self.getPropertyValue('InputType')
		instr = self.getPropertyValue('Instrument')
		prog = self.getPropertyValue('Program')
		sam = self.getPropertyValue('SamNumber')
		rinType = self.getPropertyValue('ResInputType')
		rtype = self.getPropertyValue('ResType')
		res = self.getPropertyValue('ResNumber')
		elastic = self.getProperty('ElasticOption')
		bgd = self.getPropertyValue('BackgroundOption')
		width = self.getProperty('FixWidth')
		wfile = self.getPropertyValue('WidthFile')
		resnorm = self.getProperty('ResNorm')
		resn = self.getPropertyValue('ResNormNumber')
		emin = self.getPropertyValue('EnergyMin')
		emax = self.getPropertyValue('EnergyMax')
		nbin = self.getPropertyValue('SamBinning')
		nrbin = self.getPropertyValue('ResBinning')
		nbins = [nbin, nrbin]

		sname = instr+'_'+sam
		rname = instr+'_'+res
		rsname = instr+resn
		erange = [emin, emax]
		if elastic:
			o_el = 1
		else:
			o_el = 0
		if bgd == 'Sloping':
			o_bgd = 2
		if bgd == 'Flat':
			o_bgd = 1
		if bgd == 'Zero':
			o_bgd = 0
		if width:
			o_w1 = 1
		else:
			o_w1 = 0
		if resnorm:
			o_res = 1
		else:
			o_res = 0
		fitOp = [o_el, o_bgd, o_w1, o_res]
		verbOp = self.getProperty('Verbose')
		plotOp = self.getPropertyValue('Plot')
		saveOp = self.getProperty('Save')
		Main.QLStart(prog,inType,sname,rinType,rname,rtype,rsname,erange,nbins,fitOp,wfile,verbOp,plotOp,saveOp)
Пример #8
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectMuscat as Main
        run_f2py_compatibility_test()

        self.log().information('Muscat input')
        prefix = self.getPropertyValue('Instrument')
        ana = self.getPropertyValue('Analyser')
        geom = self.getPropertyValue('Geom')
        sam = self.getPropertyValue('SamNumber')
        sqwi = self.getPropertyValue('SqwInput')
        sname = prefix + sam + '_' + ana
        sqw = prefix + sqwi + '_' + ana

        NRUN1 = self.getPropertyValue('NR1')
        NRUN2 = self.getPropertyValue('NR2')
        NMST = self.getPropertyValue('Nms')
        JRAND = 12345
        MRAND = 67890
        neut = [int(NRUN1), int(NRUN2), int(JRAND), int(MRAND), int(NMST)]

        HEIGHT = 3.0
        alfa = self.getPropertyValue('DetAngle')
        THICK = self.getPropertyValue('Thick')
        WIDTH = self.getPropertyValue('Width')
        HEIGHT = self.getPropertyValue('Height')
        if geom == 'Flat':
            beam = [float(THICK), float(WIDTH), float(HEIGHT), float(alfa)]
        if geom == 'Cyl':
            beam = [float(THICK),
                    float(WIDTH),
                    float(HEIGHT), 0.0]  #beam = [WIDTH, WIDTH2, HEIGHT, 0.0]
        dens = self.getPropertyValue('Density')
        sigb = self.getPropertyValue('SigScat')
        siga = self.getPropertyValue('SigAbs')
        temp = self.getPropertyValue('Temperature')
        sam = [float(temp), float(dens), float(siga), float(sigb)]

        kr1 = 1
        verbOp = self.getProperty('Verbose').value
        plotOp = self.getPropertyValue('Plot')
        saveOp = self.getProperty('Save').value
        Main.MuscatDataStart(sname, geom, neut, beam, sam, sqw, kr1, verbOp,
                             plotOp, saveOp)
Пример #9
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectBayes as Main

        run_f2py_compatibility_test()

        self.log().information('ResNorm input')
        inType = self.getPropertyValue('InputType')
        prefix = self.getPropertyValue('Instrument')
        ana = self.getPropertyValue('Analyser')
        van = self.getPropertyValue('VanNumber')
        rinType = self.getPropertyValue('ResInputType')
        res = self.getPropertyValue('ResNumber')
        emin = self.getPropertyValue('EnergyMin')
        emax = self.getPropertyValue('EnergyMax')
        nbin = self.getPropertyValue('VanBinning')

        vname = prefix + van + '_' + ana + '_red'
        rname = prefix + res + '_' + ana + '_res'
        erange = [float(emin), float(emax)]
        verbOp = self.getProperty('Verbose').value
        plotOp = self.getPropertyValue('Plot')
        saveOp = self.getProperty('Save').value

        workdir = config['defaultsave.directory']
        if inType == 'File':
            vpath = os.path.join(workdir,
                                 vname + '.nxs')  # path name for van nxs file
            LoadNexusProcessed(Filename=vpath, OutputWorkspace=vname)
            Vmessage = 'Vanadium from File : ' + vpath
        else:
            Vmessage = 'Vanadium from Workspace : ' + vname
        if rinType == 'File':
            rpath = os.path.join(workdir,
                                 rname + '.nxs')  # path name for res nxs file
            LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
            Rmessage = 'Resolution from File : ' + rpath
        else:
            Rmessage = 'Resolution from Workspace : ' + rname
        if verbOp:
            logger.notice(Vmessage)
            logger.notice(Rmessage)
        Main.ResNormRun(vname, rname, erange, nbin, verbOp, plotOp, saveOp)
Пример #10
0
	def PyExec(self):
                from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform
                
                if is_supported_f2py_platform():
                        import IndirectMuscat as Main
		run_f2py_compatibility_test()

		self.log().information('Muscat input')
		prefix = self.getPropertyValue('Instrument')
		ana = self.getPropertyValue('Analyser')
		geom = self.getPropertyValue('Geom')
		sam = self.getPropertyValue('SamNumber')
		sqwi = self.getPropertyValue('SqwInput')
		sname = prefix+sam+'_'+ana
		sqw = prefix+sqwi+'_'+ana

		NRUN1 = self.getPropertyValue('NR1')
		NRUN2 = self.getPropertyValue('NR2')
		NMST = self.getPropertyValue('Nms')
		JRAND = 12345
		MRAND = 67890
		neut = [int(NRUN1), int(NRUN2), int(JRAND), int(MRAND), int(NMST)]

		HEIGHT = 3.0
		alfa = self.getPropertyValue('DetAngle')
		THICK = self.getPropertyValue('Thick')
		WIDTH = self.getPropertyValue('Width')
		HEIGHT = self.getPropertyValue('Height')
		if geom == 'Flat':
			beam = [float(THICK), float(WIDTH), float(HEIGHT), float(alfa)]
		if geom == 'Cyl':
			beam = [float(THICK), float(WIDTH), float(HEIGHT), 0.0]        #beam = [WIDTH, WIDTH2, HEIGHT, 0.0]
		dens = self.getPropertyValue('Density')
		sigb = self.getPropertyValue('SigScat')
		siga = self.getPropertyValue('SigAbs')
		temp = self.getPropertyValue('Temperature')
		sam = [float(temp), float(dens), float(siga), float(sigb)]

		kr1 = 1
		verbOp = self.getProperty('Verbose').value
		plotOp = self.getPropertyValue('Plot')
		saveOp = self.getProperty('Save').value
		Main.MuscatDataStart(sname,geom,neut,beam,sam,sqw,kr1,verbOp,plotOp,saveOp)
Пример #11
0
  def PyExec(self):
    from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

    if is_supported_f2py_platform():
            import IndirectBayes as Main

    run_f2py_compatibility_test()
    
    self.log().information('ResNorm input')
    inType = self.getPropertyValue('InputType')
    prefix = self.getPropertyValue('Instrument')
    ana = self.getPropertyValue('Analyser')
    van = self.getPropertyValue('VanNumber')
    rinType = self.getPropertyValue('ResInputType')
    res = self.getPropertyValue('ResNumber')
    emin = self.getPropertyValue('EnergyMin')
    emax = self.getPropertyValue('EnergyMax')
    nbin = self.getPropertyValue('VanBinning')

    vname = prefix+van+'_'+ana+ '_red'
    rname = prefix+res+'_'+ana+ '_res'
    erange = [float(emin), float(emax)]
    verbOp = self.getProperty('Verbose').value
    plotOp = self.getPropertyValue('Plot')
    saveOp = self.getProperty('Save').value

    workdir = config['defaultsave.directory']
    if inType == 'File':
      vpath = os.path.join(workdir, vname+'.nxs')              # path name for van nxs file
      LoadNexusProcessed(Filename=vpath, OutputWorkspace=vname)
      Vmessage = 'Vanadium from File : '+vpath
    else:
      Vmessage = 'Vanadium from Workspace : '+vname
    if rinType == 'File':
      rpath = os.path.join(workdir, rname+'.nxs')                # path name for res nxs file
      LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
      Rmessage = 'Resolution from File : '+rpath
    else:
      Rmessage = 'Resolution from Workspace : '+rname
    if verbOp:
      logger.notice(Vmessage)
      logger.notice(Rmessage)
    Main.ResNormRun(vname,rname,erange,nbin,verbOp,plotOp,saveOp)
Пример #12
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectBayes as Main

        run_f2py_compatibility_test()

        self.log().information("ResNorm input")
        inType = self.getPropertyValue("InputType")
        prefix = self.getPropertyValue("Instrument")
        ana = self.getPropertyValue("Analyser")
        van = self.getPropertyValue("VanNumber")
        rinType = self.getPropertyValue("ResInputType")
        res = self.getPropertyValue("ResNumber")
        emin = self.getPropertyValue("EnergyMin")
        emax = self.getPropertyValue("EnergyMax")
        nbin = self.getPropertyValue("VanBinning")

        vname = prefix + van + "_" + ana + "_red"
        rname = prefix + res + "_" + ana + "_res"
        erange = [float(emin), float(emax)]
        plotOp = self.getPropertyValue("Plot")
        saveOp = self.getProperty("Save").value

        workdir = config["defaultsave.directory"]
        if inType == "File":
            vpath = os.path.join(workdir, vname + ".nxs")  # path name for van nxs file
            LoadNexusProcessed(Filename=vpath, OutputWorkspace=vname)
            Vmessage = "Vanadium from File : " + vpath
        else:
            Vmessage = "Vanadium from Workspace : " + vname
        if rinType == "File":
            rpath = os.path.join(workdir, rname + ".nxs")  # path name for res nxs file
            LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
            Rmessage = "Resolution from File : " + rpath
        else:
            Rmessage = "Resolution from Workspace : " + rname
        logger.information(Vmessage)
        logger.information(Rmessage)
        Main.ResNormRun(vname, rname, erange, nbin, plotOp, saveOp)
Пример #13
0
	def PyExec(self):
		run_f2py_compatibility_test()
		
		self.log().information('QLines input')
		inType = self.getPropertyValue('InputType')
		prefix = self.getPropertyValue('Instrument')
		ana = self.getPropertyValue('Analyser')
		prog = self.getPropertyValue('Program')
		sam = self.getPropertyValue('SamNumber')
		rinType = self.getPropertyValue('ResInputType')
		rtype = self.getPropertyValue('ResType')
		res = self.getPropertyValue('ResNumber')
		elastic = self.getProperty('ElasticOption')
		bgd = self.getPropertyValue('BackgroundOption')
		width = self.getProperty('FixWidth')
		wfile = self.getPropertyValue('WidthFile')
		resnorm = self.getProperty('ResNorm')
		resn = self.getPropertyValue('ResNormNumber')
		emin = self.getPropertyValue('EnergyMin')
		emax = self.getPropertyValue('EnergyMax')
		nbin = self.getPropertyValue('SamBinning')
		nrbin = self.getPropertyValue('ResBinning')
		nbins = [nbin, nrbin]

		if rtype == 'Res':
			rext = 'res'
		if rtype == 'Data':
			rext = 'red'
		sname = prefix+sam+'_'+ana + '_red'
		rname = prefix+res+'_'+ana + '_' + rext
		rsname = prefix+resn+'_'+ana + '_ResNorm_Paras'
		erange = [float(emin), float(emax)]
		if elastic:
			o_el = 1
		else:
			o_el = 0
		if bgd == 'Sloping':
			o_bgd = 2
		if bgd == 'Flat':
			o_bgd = 1
		if bgd == 'Zero':
			o_bgd = 0
		if width:
			o_w1 = 1
		else:
			o_w1 = 0
		if resnorm:
			o_res = 1
		else:
			o_res = 0
		fitOp = [o_el, o_bgd, o_w1, o_res]
		loopOp = self.getProperty('Sequence')
		verbOp = self.getProperty('Verbose')
		plotOp = self.getPropertyValue('Plot')
		saveOp = self.getProperty('Save')

		workdir = config['defaultsave.directory']
		if inType == 'File':
			spath = os.path.join(workdir, sname+'.nxs')		# path name for sample nxs file
			LoadNexusProcessed(Filename=spath, OutputWorkspace=sname)
			Smessage = 'Sample from File : '+spath
		else:
			Smessage = 'Sample from Workspace : '+sname
		if rinType == 'File':
			rpath = os.path.join(workdir, rname+'.nxs')		# path name for res nxs file
			LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
			Rmessage = 'Resolution from File : '+rpath
		else:
			Rmessage = 'Resolution from Workspace : '+rname
		if verbOp:
			logger.notice(Smessage)
			logger.notice(Rmessage)
		if fitOp[3] == 1:
			path = os.path.join(workdir, rsname+'.nxs')	# path name for resnnrm nxs file
			LoadNexusProcessed(Filename=path, OutputWorkspace='ResNorm')
		Main.QLRun(prog,sname,rname,rsname,erange,nbins,fitOp,wfile,loopOp,verbOp,plotOp,saveOp)
Пример #14
0
    def PyExec(self):
        from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

        if is_supported_f2py_platform():
            import IndirectBayes as Main

        run_f2py_compatibility_test()

        self.log().information('QLines input')
        inType = self.getPropertyValue('InputType')
        prefix = self.getPropertyValue('Instrument')
        ana = self.getPropertyValue('Analyser')
        prog = self.getPropertyValue('Program')
        sam = self.getPropertyValue('SamNumber')
        rinType = self.getPropertyValue('ResInputType')
        rtype = self.getPropertyValue('ResType')
        res = self.getPropertyValue('ResNumber')
        elastic = self.getProperty('ElasticOption').value
        bgd = self.getPropertyValue('BackgroundOption')
        width = self.getProperty('FixWidth').value
        wfile = self.getPropertyValue('WidthFile')
        rsnormType = self.getPropertyValue('ResNormInputType')
        resnorm = self.getProperty('ResNorm').value
        resn = self.getPropertyValue('ResNormNumber')
        emin = self.getPropertyValue('EnergyMin')
        emax = self.getPropertyValue('EnergyMax')
        nbin = self.getPropertyValue('SamBinning')
        nrbin = self.getPropertyValue('ResBinning')
        nbins = [nbin, nrbin]

        if rtype == 'Res':
            rext = 'res'
        if rtype == 'Data':
            rext = 'red'
        sname = prefix + sam + '_' + ana + '_red'
        rname = prefix + res + '_' + ana + '_' + rext
        rsname = prefix + resn + '_' + ana + '_ResNorm_Paras'
        erange = [float(emin), float(emax)]

        fitOp = [elastic, bgd, width, resnorm]
        loopOp = self.getProperty('Sequence').value
        verbOp = self.getProperty('Verbose').value
        plotOp = self.getPropertyValue('Plot')
        saveOp = self.getProperty('Save').value

        workdir = config['defaultsave.directory']
        if inType == 'File':
            spath = os.path.join(workdir, sname +
                                 '.nxs')  # path name for sample nxs file
            LoadNexusProcessed(Filename=spath, OutputWorkspace=sname)
            Smessage = 'Sample from File : ' + spath
        else:
            Smessage = 'Sample from Workspace : ' + sname
        if rinType == 'File':
            rpath = os.path.join(workdir,
                                 rname + '.nxs')  # path name for res nxs file
            LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
            Rmessage = 'Resolution from File : ' + rpath
        else:
            Rmessage = 'Resolution from Workspace : ' + rname

        if resnorm:
            if rsnormType == 'File':
                rpath = os.path.join(workdir, rsname +
                                     '.nxs')  # path name for res nxs file
                LoadNexusProcessed(Filename=rpath, OutputWorkspace=rsname)
                Rmessage = 'ResNorm from File : ' + rpath
            else:
                Rmessage = 'ResNorm from Workspace : ' + rsname

        if verbOp:
            logger.notice(Smessage)
            logger.notice(Rmessage)

        rsname = rsname[:-6]

        Main.QLRun(prog, sname, rname, rsname, erange, nbins, fitOp, wfile,
                   loopOp, plotOp, saveOp)
Пример #15
0
    def PyExec(self):
        run_f2py_compatibility_test()

        from IndirectBayes import (CalcErange, GetXYE)
        from IndirectCommon import (CheckXrange, CheckAnalysersOrEFixed, getEfixed, GetThetaQ, CheckHistZero)
        setup_prog = Progress(self, start=0.0, end=0.3, nreports=5)
        logger.information('BayesStretch input')
        logger.information('Sample is %s' % self._sam_name)
        logger.information('Resolution is %s' % self._res_name)

        setup_prog.report('Converting to binary for Fortran')
        fitOp = self._encode_fit_ops(self._elastic, self._background)

        setup_prog.report('Establishing save path')
        workdir = self._establish_save_path()

        setup_prog.report('Checking X Range')
        CheckXrange(self._erange, 'Energy')

        setup_prog.report('Checking Analysers')
        CheckAnalysersOrEFixed(self._sam_name, self._res_name)
        setup_prog.report('Obtaining EFixed, theta and Q')
        efix = getEfixed(self._sam_name)
        theta, Q = GetThetaQ(self._sam_name)

        setup_prog.report('Checking Histograms')
        nsam, ntc = CheckHistZero(self._sam_name)

        # check if we're performing a sequential fit
        if not self._loop:
            nsam = 1

        logger.information('Version is Stretch')
        logger.information('Number of spectra = %s ' % nsam)
        logger.information('Erange : %f to %f ' % (self._erange[0], self._erange[1]))

        setup_prog.report('Creating FORTRAN Input')
        fname = self._sam_name[:-4] + '_Stretch'
        wrks = os.path.join(workdir, self._sam_name[:-4])
        logger.information('lptfile : %s_Qst.lpt' % wrks)
        lwrk = len(wrks)
        wrks.ljust(140, ' ')
        wrkr = self._res_name
        wrkr.ljust(140, ' ')
        eBet0 = np.zeros(self._nbet)  # set errors to zero
        eSig0 = np.zeros(self._nsig)  # set errors to zero
        rscl = 1.0
        Qaxis = ''

        workflow_prog = Progress(self, start=0.3, end=0.7, nreports=nsam * 3)

        # Empty arrays to hold Sigma and Bet x,y,e values
        xSig, ySig, eSig = [], [], []
        xBet, yBet, eBet = [], [], []

        for m in range(nsam):
            logger.information('Group %i at angle %f' % (m, theta[m]))
            nsp = m + 1
            nout, bnorm, Xdat, Xv, Yv, Ev = CalcErange(self._sam_name, m,
                                                       self._erange, self._nbins[0])
            Ndat = nout[0]
            Imin = nout[1]
            Imax = nout[2]

            # get resolution data (4096 = FORTRAN array length)
            Nb, Xb, Yb, _ = GetXYE(self._res_name, 0, 4096)
            numb = [nsam, nsp, ntc, Ndat, self._nbins[0], Imin,
                    Imax, Nb, self._nbins[1], self._nbet, self._nsig]
            reals = [efix, theta[m], rscl, bnorm]

            workflow_prog.report('Processing spectrum number %i' % m)
            xsout, ysout, xbout, ybout, zpout = Que.quest(numb, Xv, Yv, Ev, reals, fitOp,
                                                          Xdat, Xb, Yb, wrks, wrkr, lwrk)
            dataXs = xsout[:self._nsig]  # reduce from fixed FORTRAN array
            dataYs = ysout[:self._nsig]
            dataXb = xbout[:self._nbet]
            dataYb = ybout[:self._nbet]
            zpWS = fname + '_Zp' + str(m)
            if m > 0:
                Qaxis += ','
            Qaxis += str(Q[m])

            dataXz = []
            dataYz = []
            dataEz = []

            for n in range(self._nsig):
                yfit_list = np.split(zpout[:self._nsig * self._nbet], self._nsig)
                dataYzp = yfit_list[n]

                dataXz = np.append(dataXz, xbout[:self._nbet])
                dataYz = np.append(dataYz, dataYzp[:self._nbet])
                dataEz = np.append(dataEz, eBet0)

            zpWS = fname + '_Zp' + str(m)
            self._create_workspace(zpWS, [dataXz, dataYz, dataEz], self._nsig, dataXs, True)

            xSig = np.append(xSig, dataXs)
            ySig = np.append(ySig, dataYs)
            eSig = np.append(eSig, eSig0)
            xBet = np.append(xBet, dataXb)
            yBet = np.append(yBet, dataYb)
            eBet = np.append(eBet, eBet0)

            if m == 0:
                groupZ = zpWS
            else:
                groupZ = groupZ + ',' + zpWS

        # create workspaces for sigma and beta
        workflow_prog.report('Creating OutputWorkspace')
        self._create_workspace(fname + '_Sigma', [xSig, ySig, eSig], nsam, Qaxis)
        self._create_workspace(fname + '_Beta', [xBet, yBet, eBet], nsam, Qaxis)

        group = fname + '_Sigma,' + fname + '_Beta'
        fit_ws = fname + '_Fit'
        s_api.GroupWorkspaces(InputWorkspaces=group,
                              OutputWorkspace=fit_ws)
        contour_ws = fname + '_Contour'
        s_api.GroupWorkspaces(InputWorkspaces=groupZ,
                              OutputWorkspace=contour_ws)

        # Add some sample logs to the output workspaces
        log_prog = Progress(self, start=0.8, end=1.0, nreports=6)
        log_prog.report('Copying Logs to Fit workspace')
        copy_log_alg = self.createChildAlgorithm('CopyLogs', enableLogging=False)
        copy_log_alg.setProperty('InputWorkspace', self._sam_name)
        copy_log_alg.setProperty('OutputWorkspace', fit_ws)
        copy_log_alg.execute()

        log_prog.report('Adding Sample logs to Fit workspace')
        self._add_sample_logs(fit_ws, self._erange, self._nbins[0])

        log_prog.report('Copying logs to Contour workspace')
        copy_log_alg.setProperty('InputWorkspace', self._sam_name)
        copy_log_alg.setProperty('OutputWorkspace', contour_ws)
        copy_log_alg.execute()

        log_prog.report('Adding sample logs to Contour workspace')
        self._add_sample_logs(contour_ws, self._erange, self._nbins[0])
        log_prog.report('Finialising log copying')

        # sort x axis
        s_api.SortXAxis(InputWorkspace=fit_ws, OutputWorkspace=fit_ws, EnableLogging=False)
        s_api.SortXAxis(InputWorkspace=contour_ws, OutputWorkspace=contour_ws, EnableLogging=False)

        self.setProperty('OutputWorkspaceFit', fit_ws)
        self.setProperty('OutputWorkspaceContour', contour_ws)
        log_prog.report('Setting workspace properties')
Пример #16
0
	def PyExec(self):
                from IndirectImport import run_f2py_compatibility_test, is_supported_f2py_platform

                if is_supported_f2py_platform():
                        import IndirectBayes as Main

		run_f2py_compatibility_test()
		
		self.log().information('QLines input')
		inType = self.getPropertyValue('InputType')
		prefix = self.getPropertyValue('Instrument')
		ana = self.getPropertyValue('Analyser')
		prog = self.getPropertyValue('Program')
		sam = self.getPropertyValue('SamNumber')
		rinType = self.getPropertyValue('ResInputType')
		rtype = self.getPropertyValue('ResType')
		res = self.getPropertyValue('ResNumber')
		elastic = self.getProperty('ElasticOption').value
		bgd = self.getPropertyValue('BackgroundOption')
		width = self.getProperty('FixWidth').value
		wfile = self.getPropertyValue('WidthFile')
		rsnormType = self.getPropertyValue('ResNormInputType')
		resnorm = self.getProperty('ResNorm').value
		resn = self.getPropertyValue('ResNormNumber')
		emin = self.getPropertyValue('EnergyMin')
		emax = self.getPropertyValue('EnergyMax')
		nbin = self.getPropertyValue('SamBinning')
		nrbin = self.getPropertyValue('ResBinning')
		nbins = [nbin, nrbin]

		if rtype == 'Res':
			rext = 'res'
		if rtype == 'Data':
			rext = 'red'
		sname = prefix+sam+'_'+ana + '_red'
		rname = prefix+res+'_'+ana + '_' + rext
		rsname = prefix+resn+'_'+ana + '_ResNorm_Paras'
		erange = [float(emin), float(emax)]

		fitOp = [elastic, bgd, width, resnorm]
		loopOp = self.getProperty('Sequence').value
		verbOp = self.getProperty('Verbose').value
		plotOp = self.getPropertyValue('Plot')
		saveOp = self.getProperty('Save').value

		workdir = config['defaultsave.directory']
		if inType == 'File':
			spath = os.path.join(workdir, sname+'.nxs')		# path name for sample nxs file
			LoadNexusProcessed(Filename=spath, OutputWorkspace=sname)
			Smessage = 'Sample from File : '+spath
		else:
			Smessage = 'Sample from Workspace : '+sname
		if rinType == 'File':
			rpath = os.path.join(workdir, rname+'.nxs')		# path name for res nxs file
			LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname)
			Rmessage = 'Resolution from File : '+rpath
		else:
			Rmessage = 'Resolution from Workspace : '+rname

		if resnorm:
			if rsnormType == 'File':
				rpath = os.path.join(workdir, rsname+'.nxs')		# path name for res nxs file
				LoadNexusProcessed(Filename=rpath, OutputWorkspace=rsname)
				Rmessage = 'ResNorm from File : '+rpath
			else:
				Rmessage = 'ResNorm from Workspace : '+rsname

		if verbOp:
			logger.notice(Smessage)
			logger.notice(Rmessage)

		rsname = rsname[:-6]

		Main.QLRun(prog,sname,rname,rsname,erange,nbins,fitOp,wfile,loopOp,verbOp,plotOp,saveOp)