Changeset 2166

Timestamp:

Mar 11, 2016 2:29:20 PM (8 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:

• GSASIIIO.py (modified) (1 diff)
• GSASIIgrid.py (modified) (1 diff)
• GSASIImath.py (modified) (1 diff)
• GSASIIphsGUI.py (modified) (4 diffs)
• GSASIIpwd.py (modified) (3 diffs)

trunk/GSASIIIO.py

@@ -2409 +2409 @@
                 else:
                     newVals.append(float(val))                
-            atomRec = [atomName,atomType,'',newVals[0],newVals[1],newVals[2],newVals[4],newVals[3]/80.]
+            atomRec = [atomName,atomType,'',newVals[0],newVals[1],newVals[2],newVals[4],newVals[3]/78.9568]
             Layer['Layers'][-1]['Atoms'].append(atomRec)
             N += 1

trunk/GSASIIgrid.py

@@ -1636 +1636 @@
         self.LayerData.Append(menu=wx.Menu(title=''),title='Select tab')
         self.LayerDataEdit = wx.Menu(title='')
-        self.LayerData.Append(menu=self.LayerDataEdit, title='Edit')
+        self.LayerData.Append(menu=self.LayerDataEdit, title='Operations')
         self.LayerDataEdit.Append(id=wxID_LOADDIFFAX, kind=wx.ITEM_NORMAL,text='Load from DIFFaX file',
             help='Load layer info from DIFFaX file')

trunk/GSASIImath.py

@@ -825 +825 @@
     except KeyError:
         return Parms['Lam1'][1]
+        
+def getMeanWave(Parms):
+    '''returns mean wavelength from Instrument parameters dictionary
+    
+    :param dict Parms: Instrument parameters;
+        must contain:
+        Lam: single wavelength
+        or
+        Lam1,Lam2: Ka1,Ka2 radiation wavelength
+        I(L2)/I(L1): Ka2/Ka1 ratio
+    
+    :returns: float wave: mean wavelength
+    
+    '''
+    try:
+        return Parms['Lam'][1]
+    except KeyError:
+        meanLam = (Parms['Lam1'][1]+Parms['I(L2)/I(L1)'][1]*Parms['Lam2'][1])/   \
+            (1.+Parms['I(L2)/I(L1)'][1])
+        return meanLam
+    
         
 def El2Mass(Elements):

trunk/GSASIIphsGUI.py

@@ -2700 +2700 @@
         def StackSizer():
             
+            stackChoice = ['recursive','explicit',]
+            seqChoice = ['random','list',]
+            numChoice = [' ','infinite',]  
+                      
             def OnStackType(event):
-                Layers['Stacking'][0] = stackType.GetValue()
+                data['Layers']['Stacking'][0] = stackType.GetValue()
                 wx.CallAfter(UpdateLayerData)
                 
@@ -2707 +2711 @@
                 val = numLayers.GetValue()
                 if val == 'infinite':
-                    Layers['Stacking'][1] = val
+                    data['Layers']['Stacking'][1] = val
                 else:
                     if int(val) > 1032:
-                        Layers['Stacking'][1] = 'infinite'
+                        data['Layers']['Stacking'][1] = 'infinite'
                     else:
-                        Layers['Stacking'][1] = val
+                        data['Layers']['Stacking'][1] = val
                 numLayers.SetValue(val)
                 
             def OnSeqType(event):
-                Layers['Stacking'][1] = seqType.GetValue()
+                data['Layers']['Stacking'][1] = seqType.GetValue()
+                wx.CallAfter(UpdateLayerData)
                 
             def OnStackList(event):
@@ -2738 +2743 @@
                     except ValueError:
                         stack += ' Error in string'
-                Layers['Stacking'][2] = stack
+                data['Layers']['Stacking'][2] = stack
                 stackList.SetValue(stack)
             
-            stackChoice = ['recursive','explicit',]
-            seqChoice = ['random','list',]
-            numChoice = [' ','infinite',]            
             stackSizer = wx.BoxSizer(wx.VERTICAL)
             stackSizer.Add(wx.StaticText(layerData,label=' Layer stacking parameters:'),0,WACV)
@@ -2856 +2858 @@
         
     def OnSimulate(event):
-        print 'simulate PWDR pattern'
+        UseList = []
+        for item in data['Histograms']:
+            if 'PWDR' in item:
+                UseList.append(item)
+        if not UseList:
+            wx.MessageBox('No PWDR data for this phase to simulate',caption='Data error',style=wx.ICON_EXCLAMATION)
+            return
+        dlg = wx.SingleChoiceDialog(G2frame,'Data to simulate','Select',UseList)
+        if dlg.ShowModal() == wx.ID_OK:
+            sel = dlg.GetSelection()
+            HistName = UseList[sel]
+        else:
+            return
+        dlg.Destroy()
+        PWDR = data['Histograms'][HistName]
+        G2frame.PatternId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,HistName)
+        
+        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
+            G2frame,G2frame.PatternId, 'Limits'))[1]
+        inst = G2frame.PatternTree.GetItemPyData(
+            G2gd.GetPatternTreeItemId(G2frame,G2frame.PatternId, 'Instrument Parameters'))[0]
+        if 'T' in inst['Type'][0]:
+            wx.MessageBox("Can't simulate neutron TOF patterns yet",caption='Data error',style=wx.ICON_EXCLAMATION)
+            return            
+        profile = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)[1]
+            
+        G2pwd.StackSim(data['Layers'],HistName,limits,inst,profile)
+        G2plt.PlotPatterns(G2frame,plotType='PWDR')
         
 ################################################################################

trunk/GSASIIpwd.py

@@ -16 +16 @@
 import math
 import time
+import os
+import subprocess as subp
 
 import numpy as np
@@ -325 +327 @@
         
     return auxPlot
-        
+
+################################################################################        
 #GSASII peak fitting routines: Finger, Cox & Jephcoat model        
+################################################################################
 
 def factorize(num):
@@ -1729 +1733 @@
     return YI,WYI
     
+################################################################################
+# Stacking fault simulation codes
+################################################################################
+
+def StackSim(Layers,HistName,limits,inst,profile):
+    '''Simulate powder pattern from stacking faults using DIFFaX
+    
+    param: Layers dict: 'Laue':'-1','Cell':[False,1.,1.,1.,90.,90.,90,1.],
+                        'Width':[[10.,10.],[False,False]],'Toler':0.01,'AtInfo':{},
+                        'Layers':[],'Stacking':[],'Transitions':[]}
+    param: HistName str: histogram name to simulate 'PWDR...'
+    param: limits list: min/max 2-theta to be calculated
+    param: inst dict: instrumnet parameters dictionary
+    param: profile list: powder pattern data
+    
+    all updated in place    
+    '''
+    import atmdata
+    path = sys.path
+    for name in path:
+        if 'bin' in name:
+            DIFFaX = name+'/DIFFaX.exe'
+            break
+    # make form factor file that DIFFaX wants - atom types are GSASII style
+    sf = open('data.sfc','w')
+    sf.write('GSASII special form factor file for DIFFaX\n\n')
+    atTypes = Layers['AtInfo'].keys()
+    if 'H' not in atTypes:
+        atTypes.insert(0,'H')
+    for atType in atTypes:
+        if atType == 'H': 
+            blen = -.3741
+        else:
+            blen = Layers['AtInfo'][atType]['Isotopes']['Nat. Abund.']['SL'][0]
+        Adat = atmdata.XrayFF[atType]
+        text = '%4s'%(atType.ljust(4))
+        for i in range(4):
+            text += '%11.6f%11.6f'%(Adat['fa'][i],Adat['fb'][i])
+        text += '%11.6f%11.6f'%(Adat['fc'],blen)
+        text += '%3d\n'%(Adat['Z'])
+        sf.write(text)
+    sf.close()
+    #make DIFFaX control.dif file - future use GUI to set some of these flags
+    x0 = profile[0]
+    iBeg = np.searchsorted(x0,limits[0])
+    iFin = np.searchsorted(x0,limits[1])
+    x = x0[iBeg:iFin]
+    dx = x0[iBeg+1]-x0[iBeg]
+    cf = open('control.dif','w')
+    cf.write('GSASII-DIFFaX.dat\n0\n0\n3\n')
+    cf.write('%.3f %.3f %.3f\n1\n1\nend\n'%(x0[iBeg],x0[iFin],dx))
+    cf.close()
+    #make DIFFaX data file
+    df = open('GSASII-DIFFaX.dat','w')
+    df.write('INSTRUMENTAL\n')
+    if 'X' in inst['Type'][0]:
+        df.write('X-RAY\n')
+    elif 'N' in inst['Type'][0]:
+        df.write('NEUTRON\n')
+    df.write('%.4f\n'%(G2mth.getMeanWave(inst)))
+#    df.write('GAUSSIAN 0.1 TRIM\n')     #fast option - might not really matter
+    df.write('PSEUDO-VOIGT 0.1 -0.036 0.009 0.6 TRIM\n')    #slow - make a GUI option?
+    df.write('STRUCTURAL\n')
+    a,b,c = Layers['Cell'][1:4]
+    gam = Layers['Cell'][6]
+    df.write('%.4f %.4f %.4f %.3f\n'%(a,b,c,gam))
+    if 'unknown' in Layers['Laue']:
+        df.write('%s %.3f\n'%(Layers['Laue'],Layers['Toler']))
+    else:    
+        df.write('%s\n'%(Layers['Laue']))
+    df.write('%d\n'%(len(Layers['Layers'])))
+    if Layers['Width'][0][0] < 1. or Layers['Width'][0][1] < 1.:
+        df.write('%.1f %.1f\n'%(Layers['Width'][0][0]*10000.,Layers['Width'][0][0]*10000.))    #mum to A
+    layerNames = []
+    for layer in Layers['Layers']:
+        layerNames.append(layer['Name'])
+    for il,layer in enumerate(Layers['Layers']):
+        if layer['SameAs']:
+            df.write('LAYER %d = %d\n'%(il+1,layerNames.index(layer['SameAs'])+1))
+            continue
+        df.write('LAYER %d\n'%(il+1))
+        if '-1' in layer['Symm']:
+            df.write('CENTROSYMMETRIC\n')
+        else:
+            df.write('NONE\n')
+        for ia,atom in enumerate(layer['Atoms']):
+            [name,atype,Q,x,y,z,frac,Uiso] = atom
+            if '-1' in layer['Symm'] and [x,y,z] == [0.,0.,0.]:
+                frac /= 2.
+            df.write('%4s %3d %.5f %.5f %.5f %.4f %.2f\n'%(atype.ljust(6),ia,x,y,z,78.9568*Uiso,frac))
+    df.write('STACKING\n')
+    df.write('%s\n'%(Layers['Stacking'][0]))
+    if 'recursive' in Layers['Stacking'][0]:
+        df.write('%s\n'%Layers['Stacking'][1])
+    else:
+        if 'list' in Layers['Stacking'][1]:
+            Slen = len(Layers['Stacking'][2])
+            iB = 0
+            iF = 0
+            while True:
+                iF += 68
+                if iF >= Slen:
+                    break
+                iF = min(iF,Slen)
+                df.write('%s\n'%(Layers['Stacking'][2][iB:iF]))
+                iB = iF
+        else:
+            df.write('%s\n'%Layers['Stacking'][1])    
+    df.write('TRANSITIONS\n')
+    for iY in range(len(Layers['Layers'])):
+        for iX in range(len(Layers['Layers'])):
+            p,dx,dy,dz = Layers['Transitions'][iY][iX][:4]
+            df.write('%.3f %.5f %.5f %.5f\n'%(p,dx,dy,dz))        
+    df.close()    
+    time0 = time.time()
+    subp.call(DIFFaX)
+    print 'DIFFaX time = %.2fs'%(time.time()-time0)
+    X = np.loadtxt('GSASII-DIFFaX.spc')
+    profile[3][:len(X.T[1])] = X.T[1]
+    #cleanup files..
+    os.remove('data.sfc')
+    os.remove('control.dif')
+    os.remove('GSASII-DIFFaX.dat')
+    os.remove('GSASII-DIFFaX.spc')
+    
 #testing data
 NeedTestData = True