Changeset 2166


Ignore:
Timestamp:
Mar 11, 2016 2:29:20 PM (6 years ago)
Author:
vondreele
Message:

add GetMeanWave? to G2math to return Ka-bar

more work on Stacking faults - now runs DIFFaX with data from GSAS-II

result as a powder pattern returned to ycalc.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIIO.py

    r2164 r2166  
    24092409                else:
    24102410                    newVals.append(float(val))               
    2411             atomRec = [atomName,atomType,'',newVals[0],newVals[1],newVals[2],newVals[4],newVals[3]/80.]
     2411            atomRec = [atomName,atomType,'',newVals[0],newVals[1],newVals[2],newVals[4],newVals[3]/78.9568]
    24122412            Layer['Layers'][-1]['Atoms'].append(atomRec)
    24132413            N += 1
  • trunk/GSASIIgrid.py

    r2165 r2166  
    16361636        self.LayerData.Append(menu=wx.Menu(title=''),title='Select tab')
    16371637        self.LayerDataEdit = wx.Menu(title='')
    1638         self.LayerData.Append(menu=self.LayerDataEdit, title='Edit')
     1638        self.LayerData.Append(menu=self.LayerDataEdit, title='Operations')
    16391639        self.LayerDataEdit.Append(id=wxID_LOADDIFFAX, kind=wx.ITEM_NORMAL,text='Load from DIFFaX file',
    16401640            help='Load layer info from DIFFaX file')
  • trunk/GSASIImath.py

    r2154 r2166  
    825825    except KeyError:
    826826        return Parms['Lam1'][1]
     827       
     828def getMeanWave(Parms):
     829    '''returns mean wavelength from Instrument parameters dictionary
     830   
     831    :param dict Parms: Instrument parameters;
     832        must contain:
     833        Lam: single wavelength
     834        or
     835        Lam1,Lam2: Ka1,Ka2 radiation wavelength
     836        I(L2)/I(L1): Ka2/Ka1 ratio
     837   
     838    :returns: float wave: mean wavelength
     839   
     840    '''
     841    try:
     842        return Parms['Lam'][1]
     843    except KeyError:
     844        meanLam = (Parms['Lam1'][1]+Parms['I(L2)/I(L1)'][1]*Parms['Lam2'][1])/   \
     845            (1.+Parms['I(L2)/I(L1)'][1])
     846        return meanLam
     847   
    827848       
    828849def El2Mass(Elements):
  • trunk/GSASIIphsGUI.py

    r2165 r2166  
    27002700        def StackSizer():
    27012701           
     2702            stackChoice = ['recursive','explicit',]
     2703            seqChoice = ['random','list',]
     2704            numChoice = [' ','infinite',] 
     2705                     
    27022706            def OnStackType(event):
    2703                 Layers['Stacking'][0] = stackType.GetValue()
     2707                data['Layers']['Stacking'][0] = stackType.GetValue()
    27042708                wx.CallAfter(UpdateLayerData)
    27052709               
     
    27072711                val = numLayers.GetValue()
    27082712                if val == 'infinite':
    2709                     Layers['Stacking'][1] = val
     2713                    data['Layers']['Stacking'][1] = val
    27102714                else:
    27112715                    if int(val) > 1032:
    2712                         Layers['Stacking'][1] = 'infinite'
     2716                        data['Layers']['Stacking'][1] = 'infinite'
    27132717                    else:
    2714                         Layers['Stacking'][1] = val
     2718                        data['Layers']['Stacking'][1] = val
    27152719                numLayers.SetValue(val)
    27162720               
    27172721            def OnSeqType(event):
    2718                 Layers['Stacking'][1] = seqType.GetValue()
     2722                data['Layers']['Stacking'][1] = seqType.GetValue()
     2723                wx.CallAfter(UpdateLayerData)
    27192724               
    27202725            def OnStackList(event):
     
    27382743                    except ValueError:
    27392744                        stack += ' Error in string'
    2740                 Layers['Stacking'][2] = stack
     2745                data['Layers']['Stacking'][2] = stack
    27412746                stackList.SetValue(stack)
    27422747           
    2743             stackChoice = ['recursive','explicit',]
    2744             seqChoice = ['random','list',]
    2745             numChoice = [' ','infinite',]           
    27462748            stackSizer = wx.BoxSizer(wx.VERTICAL)
    27472749            stackSizer.Add(wx.StaticText(layerData,label=' Layer stacking parameters:'),0,WACV)
     
    28562858       
    28572859    def OnSimulate(event):
    2858         print 'simulate PWDR pattern'
     2860        UseList = []
     2861        for item in data['Histograms']:
     2862            if 'PWDR' in item:
     2863                UseList.append(item)
     2864        if not UseList:
     2865            wx.MessageBox('No PWDR data for this phase to simulate',caption='Data error',style=wx.ICON_EXCLAMATION)
     2866            return
     2867        dlg = wx.SingleChoiceDialog(G2frame,'Data to simulate','Select',UseList)
     2868        if dlg.ShowModal() == wx.ID_OK:
     2869            sel = dlg.GetSelection()
     2870            HistName = UseList[sel]
     2871        else:
     2872            return
     2873        dlg.Destroy()
     2874        PWDR = data['Histograms'][HistName]
     2875        G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistName)
     2876       
     2877        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
     2878            G2frame,G2frame.PatternId, 'Limits'))[1]
     2879        inst = G2frame.PatternTree.GetItemPyData(
     2880            G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
     2881        if 'T' in inst['Type'][0]:
     2882            wx.MessageBox("Can't simulate neutron TOF patterns yet",caption='Data error',style=wx.ICON_EXCLAMATION)
     2883            return           
     2884        profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
     2885           
     2886        G2pwd.StackSim(data['Layers'],HistName,limits,inst,profile)
     2887        G2plt.PlotPatterns(G2frame,plotType='PWDR')
    28592888       
    28602889################################################################################
  • trunk/GSASIIpwd.py

    r2132 r2166  
    1616import math
    1717import time
     18import os
     19import subprocess as subp
    1820
    1921import numpy as np
     
    325327       
    326328    return auxPlot
    327        
     329
     330################################################################################       
    328331#GSASII peak fitting routines: Finger, Cox & Jephcoat model       
     332################################################################################
    329333
    330334def factorize(num):
     
    17291733    return YI,WYI
    17301734   
     1735################################################################################
     1736# Stacking fault simulation codes
     1737################################################################################
     1738
     1739def StackSim(Layers,HistName,limits,inst,profile):
     1740    '''Simulate powder pattern from stacking faults using DIFFaX
     1741   
     1742    param: Layers dict: 'Laue':'-1','Cell':[False,1.,1.,1.,90.,90.,90,1.],
     1743                        'Width':[[10.,10.],[False,False]],'Toler':0.01,'AtInfo':{},
     1744                        'Layers':[],'Stacking':[],'Transitions':[]}
     1745    param: HistName str: histogram name to simulate 'PWDR...'
     1746    param: limits list: min/max 2-theta to be calculated
     1747    param: inst dict: instrumnet parameters dictionary
     1748    param: profile list: powder pattern data
     1749   
     1750    all updated in place   
     1751    '''
     1752    import atmdata
     1753    path = sys.path
     1754    for name in path:
     1755        if 'bin' in name:
     1756            DIFFaX = name+'/DIFFaX.exe'
     1757            break
     1758    # make form factor file that DIFFaX wants - atom types are GSASII style
     1759    sf = open('data.sfc','w')
     1760    sf.write('GSASII special form factor file for DIFFaX\n\n')
     1761    atTypes = Layers['AtInfo'].keys()
     1762    if 'H' not in atTypes:
     1763        atTypes.insert(0,'H')
     1764    for atType in atTypes:
     1765        if atType == 'H':
     1766            blen = -.3741
     1767        else:
     1768            blen = Layers['AtInfo'][atType]['Isotopes']['Nat. Abund.']['SL'][0]
     1769        Adat = atmdata.XrayFF[atType]
     1770        text = '%4s'%(atType.ljust(4))
     1771        for i in range(4):
     1772            text += '%11.6f%11.6f'%(Adat['fa'][i],Adat['fb'][i])
     1773        text += '%11.6f%11.6f'%(Adat['fc'],blen)
     1774        text += '%3d\n'%(Adat['Z'])
     1775        sf.write(text)
     1776    sf.close()
     1777    #make DIFFaX control.dif file - future use GUI to set some of these flags
     1778    x0 = profile[0]
     1779    iBeg = np.searchsorted(x0,limits[0])
     1780    iFin = np.searchsorted(x0,limits[1])
     1781    x = x0[iBeg:iFin]
     1782    dx = x0[iBeg+1]-x0[iBeg]
     1783    cf = open('control.dif','w')
     1784    cf.write('GSASII-DIFFaX.dat\n0\n0\n3\n')
     1785    cf.write('%.3f %.3f %.3f\n1\n1\nend\n'%(x0[iBeg],x0[iFin],dx))
     1786    cf.close()
     1787    #make DIFFaX data file
     1788    df = open('GSASII-DIFFaX.dat','w')
     1789    df.write('INSTRUMENTAL\n')
     1790    if 'X' in inst['Type'][0]:
     1791        df.write('X-RAY\n')
     1792    elif 'N' in inst['Type'][0]:
     1793        df.write('NEUTRON\n')
     1794    df.write('%.4f\n'%(G2mth.getMeanWave(inst)))
     1795#    df.write('GAUSSIAN 0.1 TRIM\n')     #fast option - might not really matter
     1796    df.write('PSEUDO-VOIGT 0.1 -0.036 0.009 0.6 TRIM\n')    #slow - make a GUI option?
     1797    df.write('STRUCTURAL\n')
     1798    a,b,c = Layers['Cell'][1:4]
     1799    gam = Layers['Cell'][6]
     1800    df.write('%.4f %.4f %.4f %.3f\n'%(a,b,c,gam))
     1801    if 'unknown' in Layers['Laue']:
     1802        df.write('%s %.3f\n'%(Layers['Laue'],Layers['Toler']))
     1803    else:   
     1804        df.write('%s\n'%(Layers['Laue']))
     1805    df.write('%d\n'%(len(Layers['Layers'])))
     1806    if Layers['Width'][0][0] < 1. or Layers['Width'][0][1] < 1.:
     1807        df.write('%.1f %.1f\n'%(Layers['Width'][0][0]*10000.,Layers['Width'][0][0]*10000.))    #mum to A
     1808    layerNames = []
     1809    for layer in Layers['Layers']:
     1810        layerNames.append(layer['Name'])
     1811    for il,layer in enumerate(Layers['Layers']):
     1812        if layer['SameAs']:
     1813            df.write('LAYER %d = %d\n'%(il+1,layerNames.index(layer['SameAs'])+1))
     1814            continue
     1815        df.write('LAYER %d\n'%(il+1))
     1816        if '-1' in layer['Symm']:
     1817            df.write('CENTROSYMMETRIC\n')
     1818        else:
     1819            df.write('NONE\n')
     1820        for ia,atom in enumerate(layer['Atoms']):
     1821            [name,atype,Q,x,y,z,frac,Uiso] = atom
     1822            if '-1' in layer['Symm'] and [x,y,z] == [0.,0.,0.]:
     1823                frac /= 2.
     1824            df.write('%4s %3d %.5f %.5f %.5f %.4f %.2f\n'%(atype.ljust(6),ia,x,y,z,78.9568*Uiso,frac))
     1825    df.write('STACKING\n')
     1826    df.write('%s\n'%(Layers['Stacking'][0]))
     1827    if 'recursive' in Layers['Stacking'][0]:
     1828        df.write('%s\n'%Layers['Stacking'][1])
     1829    else:
     1830        if 'list' in Layers['Stacking'][1]:
     1831            Slen = len(Layers['Stacking'][2])
     1832            iB = 0
     1833            iF = 0
     1834            while True:
     1835                iF += 68
     1836                if iF >= Slen:
     1837                    break
     1838                iF = min(iF,Slen)
     1839                df.write('%s\n'%(Layers['Stacking'][2][iB:iF]))
     1840                iB = iF
     1841        else:
     1842            df.write('%s\n'%Layers['Stacking'][1])   
     1843    df.write('TRANSITIONS\n')
     1844    for iY in range(len(Layers['Layers'])):
     1845        for iX in range(len(Layers['Layers'])):
     1846            p,dx,dy,dz = Layers['Transitions'][iY][iX][:4]
     1847            df.write('%.3f %.5f %.5f %.5f\n'%(p,dx,dy,dz))       
     1848    df.close()   
     1849    time0 = time.time()
     1850    subp.call(DIFFaX)
     1851    print 'DIFFaX time = %.2fs'%(time.time()-time0)
     1852    X = np.loadtxt('GSASII-DIFFaX.spc')
     1853    profile[3][:len(X.T[1])] = X.T[1]
     1854    #cleanup files..
     1855    os.remove('data.sfc')
     1856    os.remove('control.dif')
     1857    os.remove('GSASII-DIFFaX.dat')
     1858    os.remove('GSASII-DIFFaX.spc')
     1859   
    17311860#testing data
    17321861NeedTestData = True
Note: See TracChangeset for help on using the changeset viewer.