Changeset 2161


Ignore:
Timestamp:
Mar 4, 2016 2:34:44 PM (6 years ago)
Author:
vondreele
Message:

Add GUI for layer stacking structures - almost complete; new phase type = 'faulted'
Add load from DIFFaX command files for stacking structures

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIIO.py

    r2152 r2161  
    962962    return Id       #last powder pattern generated
    963963           
    964 # def powderFxyeSave(G2frame,exports,powderfile):
    965 #     'Save a powder histogram as a GSAS FXYE file'
    966 #     head,tail = ospath.split(powderfile)
    967 #     name,ext = tail.split('.')
    968 #     for i,export in enumerate(exports):
    969 #         filename = ospath.join(head,name+'-%03d.'%(i)+ext)
    970 #         prmname = filename.strip(ext)+'prm'
    971 #         prm = open(prmname,'w')      #old style GSAS parm file
    972 #         PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, export)
    973 #         Inst = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame, \
    974 #             PickId, 'Instrument Parameters'))[0]
    975 #         prm.write( '            123456789012345678901234567890123456789012345678901234567890        '+'\n')
    976 #         prm.write( 'INS   BANK      1                                                               '+'\n')
    977 #         prm.write(('INS   HTYPE   %sR                                                              '+'\n')%(Inst['Type'][0]))
    978 #         if 'Lam1' in Inst:              #Ka1 & Ka2
    979 #             prm.write(('INS  1 ICONS%10.7f%10.7f    0.0000               0.990    0     0.500   '+'\n')%(Inst['Lam1'][0],Inst['Lam2'][0]))
    980 #         elif 'Lam' in Inst:             #single wavelength
    981 #             prm.write(('INS  1 ICONS%10.7f%10.7f    0.0000               0.990    0     0.500   '+'\n')%(Inst['Lam'][1],0.0))
    982 #         prm.write( 'INS  1 IRAD     0                                                               '+'\n')
    983 #         prm.write( 'INS  1I HEAD                                                                    '+'\n')
    984 #         prm.write( 'INS  1I ITYP    0    0.0000  180.0000         1                                 '+'\n')
    985 #         prm.write(('INS  1DETAZM%10.3f                                                          '+'\n')%(Inst['Azimuth'][0]))
    986 #         prm.write( 'INS  1PRCF1     3    8   0.00100                                                '+'\n')
    987 #         prm.write(('INS  1PRCF11     %15.6g%15.6g%15.6g%15.6g   '+'\n')%(Inst['U'][1],Inst['V'][1],Inst['W'][1],0.0))
    988 #         prm.write(('INS  1PRCF12     %15.6g%15.6g%15.6g%15.6g   '+'\n')%(Inst['X'][1],Inst['Y'][1],Inst['SH/L'][1]/2.,Inst['SH/L'][1]/2.))
    989 #         prm.close()
    990 #         file = open(filename,'w')
    991 #         print 'save powder pattern to file: ',filename
    992 #         x,y,w,yc,yb,yd = G2frame.PatternTree.GetItemPyData(PickId)[1]
    993 #         file.write(powderfile+'\n')
    994 #         file.write('Instrument parameter file:'+ospath.split(prmname)[1]+'\n')
    995 #         file.write('BANK 1 %d %d CONS %.2f %.2f 0 0 FXYE\n'%(len(x),len(x),\
    996 #             100.*x[0],100.*(x[1]-x[0])))
    997 #         s = list(np.sqrt(1./np.array(w)))       
    998 #         XYW = zip(x,y,s)
    999 #         for X,Y,S in XYW:
    1000 #             file.write("%15.6g %15.6g %15.6g\n" % (100.*X,Y,max(S,1.0)))
    1001 #         file.close()
    1002 #         print 'powder pattern file '+filename+' written'
    1003        
    1004 # def powderXyeSave(G2frame,exports,powderfile):
    1005 #     'Save a powder histogram as a Topas XYE file'
    1006 #     head,tail = ospath.split(powderfile)
    1007 #     name,ext = tail.split('.')
    1008 #     for i,export in enumerate(exports):
    1009 #         filename = ospath.join(head,name+'-%03d.'%(i)+ext)
    1010 #         PickId = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, export)
    1011 #         file = open(filename,'w')
    1012 #         file.write('#%s\n'%(export))
    1013 #         print 'save powder pattern to file: ',filename
    1014 #         x,y,w,yc,yb,yd = G2frame.PatternTree.GetItemPyData(PickId)[1]
    1015 #         s = list(np.sqrt(1./np.array(w)))       
    1016 #         XYW = zip(x,y,s)
    1017 #         for X,Y,W in XYW:
    1018 #             file.write("%15.6g %15.6g %15.6g\n" % (X,Y,W))
    1019 #         file.close()
    1020 #         print 'powder pattern file '+filename+' written'
    1021        
    1022964def PDFSave(G2frame,exports):
    1023965    'Save a PDF G(r) and S(Q) in column formats'
     
    23712313    else:
    23722314        print('No Export routine supports extension '+extension)
     2315       
     2316def ReadDIFFaX(DIFFaXfile):
     2317    print 'read ',DIFFaXfile
     2318    Layer = {'Laue':'-1','Cell':[False,1.,1.,1.,90.,90.,90,1.],'Width':[[10.,10.],[False,False]],
     2319        'Layers':[],'Stacking':[],'Transitions':[],'Toler':0.01}
     2320    df = open(DIFFaXfile,'r')
     2321    lines = df.readlines()
     2322    df.close()
     2323    struct = False
     2324    Struct = []
     2325    stack = False
     2326    Stack = []
     2327    trans = False
     2328    Trans = []
     2329    instr = False
     2330    for diff in lines:
     2331        diff = diff[:-1].lower()
     2332        if '!'  in diff:
     2333            continue
     2334        while '}' in diff: #strip comments
     2335            iB = diff.index('{')
     2336            iF = diff.index('}')+1
     2337            if iB:
     2338                diff = diff[:iB]
     2339            else:
     2340                diff = diff[iF:]
     2341        if not diff:
     2342            continue
     2343        if diff.strip() == 'instrumental':
     2344            instr = True
     2345            continue
     2346        if diff.strip() == 'structural':
     2347            instr = False
     2348            struct = True
     2349            continue
     2350        elif diff.strip() == 'stacking':
     2351            struct = False
     2352            stack = True
     2353            continue
     2354        elif diff.strip() == 'transitions':
     2355            stack = False
     2356            trans = True
     2357            continue
     2358        diff = diff.strip()
     2359        if struct:
     2360            if diff:
     2361                Struct.append(diff)
     2362        elif stack:
     2363            if diff:
     2364                Stack.append(diff)
     2365        elif trans:
     2366            if diff:
     2367                Trans.append(diff)
     2368   
     2369#STRUCTURE records
     2370    laueRec = Struct[1].split()
     2371    Layer['Laue'] = laueRec[0]
     2372    if Layer['Laue'] == 'unknown' and len(laueRec) > 1:
     2373        Layer['Toler'] = float(laueRec[1])    #tolerance for 'unknown'?
     2374    if Layer['Laue'] == '2/m(1)': Layer['Laue'] = '2/m(c)'
     2375    if Layer['Laue'] == '2/m(2)': Layer['Laue'] = '2/m(ab)'
     2376    cell = Struct[0].split()
     2377    Layer['Cell'] = [False,float(cell[0]),float(cell[1]),float(cell[2]),90.,90.,float(cell[3]),1.0]
     2378    nLayers = int(Struct[2])
     2379    N = 3
     2380    if 'layer' not in Struct[3]:
     2381        N = 4
     2382        if Struct[3] != 'infinite':
     2383            width = Struct[3].split()
     2384            Layer['Width'][0] = [float(width[0]),float(width[1])]
     2385    for nL in range(nLayers):
     2386        if '=' in Struct[N]:
     2387            name = Struct[N].split('=')
     2388            sameas = int(name[1])-1
     2389            Layer['Layers'].append({'Name':name[0],'SameAs':Layer['Layers'][sameas]['Name'],'Symm':'None','Atoms':[]})
     2390            N += 1
     2391            continue
     2392        Symm = 'None'
     2393        if 'centro' in Struct[N+1]: Symm = '-1'
     2394        Layer['Layers'].append({'Name':Struct[N],'SameAs':'','Symm':Symm,'Atoms':[]})
     2395        N += 2
     2396        iatm = 0
     2397        while 'layer' not in Struct[N]:
     2398            atom = Struct[N][4:].split()
     2399            atomType = G2el.FixValence(Struct[N][:4]).strip().capitalize()
     2400            atomName = '%s(%s)'%(atomType,atom[0])
     2401            newVals = []
     2402            for val in atom[1:6]:
     2403                if '/' in val:
     2404                    newVals.append(eval(val+'.'))
     2405                else:
     2406                    newVals.append(float(val))               
     2407            atomRec = [atomName,atomType,'',newVals[0],newVals[1],newVals[2],newVals[4],newVals[3]/80.]
     2408            Layer['Layers'][-1]['Atoms'].append(atomRec)
     2409            N += 1
     2410            if N > len(Struct)-1:
     2411                break
     2412#TRANSITIONS records
     2413    transArray = []
     2414    N = 0
     2415    for i in range(nLayers):
     2416        transArray.append([])
     2417        for j in range(nLayers):
     2418            vals = Trans[N].split()
     2419            newVals = []
     2420            for val in vals[:4]:
     2421                if '/' in val:
     2422                    newVals.append(eval(val+'.'))
     2423                else:
     2424                    newVals.append(float(val))
     2425            transArray[-1].append(newVals+['',False])
     2426            N += 1
     2427    Layer['Transitions'] = transArray
     2428#STACKING records
     2429    Layer['Stacking'] = [Stack[0],'']
     2430    if Stack[0] == 'recursive':
     2431        Layer['Stacking'][1] = Stack[1]
     2432    elif Stack[0] == 'explicit':
     2433        if Stack[1] == 'random':
     2434            Layer['Stacking'][1] = Stack[1]
     2435        else:
     2436            Layer['Stacking'][1] = 'list'
     2437            Layer['Stacking'].append('')
     2438            for stack in Stack[2:]:
     2439                Layer['Stacking'][2] += ' '+stack
     2440    return Layer
    23732441
    23742442def ReadCIF(URLorFile):
  • trunk/GSASIIgrid.py

    r2154 r2161  
    8686[ wxID_CLEARTEXTURE,wxID_REFINETEXTURE,
    8787] = [wx.NewId() for item in range(2)]
     88
     89[ wxID_LOADDIFFAX,
     90] = [wx.NewId() for item in range(1)]
    8891
    8992[ wxID_PAWLEYLOAD, wxID_PAWLEYESTIMATE, wxID_PAWLEYUPDATE,
     
    16261629        self.WavesDataEdit.Append(id=wxID_WAVEVARY, kind=wx.ITEM_NORMAL,text='Global wave vary',
    16271630            help='Global setting of wave vary flags')
     1631        self.PostfillDataMenu()
     1632       
     1633        # Phase / Layer tab
     1634        self.LayerData = wx.MenuBar()
     1635        self.PrefillDataMenu(self.LayerData,helpType='Layer Data', helpLbl='Stacking fault layers')
     1636        self.LayerData.Append(menu=wx.Menu(title=''),title='Select tab')
     1637        self.LayerDataEdit = wx.Menu(title='')
     1638        self.LayerData.Append(menu=self.LayerDataEdit, title='Edit')
     1639        self.LayerDataEdit.Append(id=wxID_LOADDIFFAX, kind=wx.ITEM_NORMAL,text='Load from DIFFaX file',
     1640            help='Load layer info from DIFFaX file')
    16281641        self.PostfillDataMenu()
    16291642                 
  • trunk/GSASIIphsGUI.py

    r2154 r2161  
    340340        if General.GetSizer():
    341341            General.GetSizer().Clear(True)
    342         phaseTypes = ['nuclear','modulated','magnetic','macromolecular']
     342        phaseTypes = ['nuclear','modulated','magnetic','macromolecular','faulted']
    343343        SetupGeneral()
    344344        generalData = data['General']
     
    400400                            pass
    401401#                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
     402                        if 'Layers' in pages:
     403                            pass
     404#                            G2frame.dataDisplay.DeletePage(pages.index('Layers'))
    402405                        if 'Wave Data' not in pages:
    403406                            G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
     
    405408                            Id = wx.NewId()
    406409                            TabSelectionIdDict[Id] = 'Wave Data'
     410                        wx.CallAfter(UpdateGeneral)
     411                    elif generalData['Type'] == 'faulted':
     412                        G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
     413                        if 'Wave Data' in pages:
     414                            pass
     415#                            G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     416                        if 'MC/SA' in pages:
     417                            pass
     418#                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))
     419                        if 'RB Models' in pages:
     420                            pass
     421#                            G2frame.dataDisplay.DeletePage(pages.index('RB Models'))
     422                        if 'Layers' not in pages:
     423                            if 'Layers' not in data:
     424                                data['Layers'] = {'Laue':'-1','Cell':[False,1.,1.,1.,90.,90.,90,1.],
     425                                    'Width':[[10.,10.],[False,False]],'Toler':0.01,
     426                                    'Layers':[],'Stacking':[],'Transitions':[]}
     427                            G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
     428                            G2frame.dataDisplay.InsertPage(3,G2frame.layerData,'Layers')
     429                            Id = wx.NewId()
     430                            TabSelectionIdDict[Id] = 'Layers'
    407431                        wx.CallAfter(UpdateGeneral)
    408432                    else:
     
    23602384       
    23612385################################################################################
     2386#### Layer Data page
     2387################################################################################
     2388       
     2389    def UpdateLayerData(Scroll=0):
     2390       
     2391        laueChoice = ['-1','2/m(ab)','2/m(c)','mmm','-3','-3m','4/m','4/mmm',
     2392            '6/m','6/mmm','axial','unknown']
     2393        colLabels = ['Name','Type','refine','x','y','z','frac','Uiso']
     2394        transLabels = ['Prob','Dx','Dy','Dz','refine','plot']
     2395        colTypes = [wg.GRID_VALUE_STRING,wg.GRID_VALUE_STRING,wg.GRID_VALUE_CHOICE+": ,X,XU,U,F,FX,FXU,FU",]+ \
     2396            3*[wg.GRID_VALUE_FLOAT+':10,5',]+2*[wg.GRID_VALUE_FLOAT+':10,4',] #x,y,z,frac,Uiso
     2397        transTypes = [wg.GRID_VALUE_FLOAT+':10,3',]+3*[wg.GRID_VALUE_FLOAT+':10,5',]+ \
     2398            [wg.GRID_VALUE_CHOICE+": ,P,PX,PY,PZ,PXY,PXZ,PYZ,PXYZ,X,Y,Z,XY,XZ,YZ,XYZ",wg.GRID_VALUE_BOOL,]
     2399           
     2400        def OnLaue(event):
     2401            Obj = event.GetEventObject()
     2402            data['Layers']['Laue'] = Obj.GetValue()
     2403            UpdateLayerData()
     2404       
     2405        def OnToler(event): #used when Laue = unknown
     2406            try:
     2407                val = float(toler.GetValue())
     2408            except ValueError:
     2409                val = Layers['Toler']
     2410            Layers['Toler'] = val
     2411            toler.SetValue('%.3f'%(Layers['Toler']))
     2412           
     2413        def CellSizer():
     2414           
     2415            cellGUIlist = [
     2416                [['-3','-3m','6/m','6/mmm','4/m','4/mmm'],6,zip([" a = "," c = "],["%.5f","%.5f",],[True,True],[0,2])],
     2417                [['mmm'],8,zip([" a = "," b = "," c = "],["%.5f","%.5f","%.5f"],[True,True,True],[0,1,2,])],
     2418                [['2/m(ab)','2/m(c)','-1','axial','unknown'],10,zip([" a = "," b = "," c = "," gamma = "],
     2419                    ["%.5f","%.5f","%.5f","%.3f"],[True,True,True,True],[0,1,2,3])]]
     2420               
     2421            def OnCellRef(event):
     2422                data['Layers']['Cell'][0] = cellRef.GetValue()
     2423               
     2424            def OnCellChange(event):
     2425                laue = data['Layers']['Laue']
     2426                cell = data['Layers']['Cell']
     2427                Obj = event.GetEventObject()
     2428                ObjId = cellList.index(Obj.GetId())
     2429                try:
     2430                    value = max(1.0,float(Obj.GetValue()))
     2431                except ValueError:
     2432                    if ObjId < 3:               #bad cell edge - reset
     2433                        value = controls[6+ObjId]
     2434                    else:                       #bad angle
     2435                        value = 90.
     2436                if laue in ['-3','-3m','6/m','6/mmm','4/m','4/mmm']:                   
     2437                    cell[4] = cell[5] = 90.
     2438                    cell[6] = 120.
     2439                    if laue in ['4/m','4/mmm']:
     2440                        cell[6] = 90.
     2441                    if ObjId == 0:
     2442                        cell[1] = cell[2] = value
     2443                        Obj.SetValue("%.5f"%(cell[1]))
     2444                    else:
     2445                        cell[3] = value
     2446                        Obj.SetValue("%.5f"%(cell[3]))
     2447                elif laue in ['mmm']:
     2448                    cell[ObjId+1] = value
     2449                    cell[4] = cell[5] = cell[6] = 90.
     2450                    Obj.SetValue("%.5f"%(cell[ObjId+1]))
     2451                elif laue in ['2/m']:
     2452                    cell[4] = cell[5] = 90.
     2453                    if ObjId != 3:
     2454                        cell[ObjId+1] = value
     2455                        Obj.SetValue("%.5f"%(cell[ObjId+1]))
     2456                    else:
     2457                        cell[6] = value
     2458                        Obj.SetValue("%.3f"%(cell[6]))
     2459                else:
     2460                    cell[ObjId+1] = value
     2461                    if ObjId < 3:
     2462                        Obj.SetValue("%.5f"%(cell[1+ObjId]))
     2463                    else:
     2464                        Obj.SetValue("%.3f"%(cell[1+ObjId]))                       
     2465                cell[7] = G2lat.calc_V(G2lat.cell2A(cell[1:7]))
     2466                volVal.SetLabel(' Vol = %.3f'%(cell[7]))
     2467           
     2468            cell = data['Layers']['Cell']
     2469            laue = data['Layers']['Laue']
     2470            for cellGUI in cellGUIlist:
     2471                if laue in cellGUI[0]:
     2472                    useGUI = cellGUI
     2473            cellSizer = wx.FlexGridSizer(0,useGUI[1]+1,5,5)
     2474            cellRef = wx.CheckBox(layerData,-1,label='Refine unit cell:')
     2475            cellSizer.Add(cellRef,0,WACV)
     2476            cellRef.Bind(wx.EVT_CHECKBOX, OnCellRef)
     2477            cellRef.SetValue(cell[0])
     2478            cellList = []
     2479            for txt,fmt,ifEdit,Id in useGUI[2]:
     2480                cellSizer.Add(wx.StaticText(layerData,label=txt),0,WACV)
     2481                cellVal = wx.TextCtrl(layerData,value=(fmt%(cell[Id+1])),
     2482                    style=wx.TE_PROCESS_ENTER)
     2483                cellVal.Bind(wx.EVT_TEXT_ENTER,OnCellChange)       
     2484                cellVal.Bind(wx.EVT_KILL_FOCUS,OnCellChange)
     2485                cellSizer.Add(cellVal,0,WACV)
     2486                cellList.append(cellVal.GetId())
     2487            volVal = wx.StaticText(layerData,label=' Vol = %.3f'%(cell[7]))
     2488            cellSizer.Add(volVal,0,WACV)
     2489            return cellSizer
     2490           
     2491        def WidthSizer():
     2492           
     2493            def OnWidthChange(event):
     2494                Obj = event.GetEventObject()
     2495                id = Indx[Obj]
     2496                try:
     2497                    Layers['Width'][0][id] = float(Obj.GetValue())
     2498                except ValueError:
     2499                    pass
     2500                Obj.SetValue('%.3f'%(Layers['Width'][0][id]))
     2501               
     2502            def OnRefWidth(event):
     2503                id = Indx[event.GetEventObject()]
     2504                Layers['Width'][1][id] = not Layers['Width'][1][id]
     2505           
     2506            Labels = ['a','b']
     2507            widths = Layers['Width'][0]
     2508            flags = Layers['Width'][1]
     2509            Indx = {}
     2510            widthSizer = wx.BoxSizer(wx.HORIZONTAL)
     2511            for i in range(2):
     2512                widthSizer.Add(wx.StaticText(layerData,label=' layer width(%s): '%(Labels[i])),0,WACV)
     2513                widthVal = wx.TextCtrl(layerData,value='%.3f'%(widths[i]),style=wx.TE_PROCESS_ENTER)
     2514                widthVal.Bind(wx.EVT_TEXT_ENTER,OnWidthChange)       
     2515                widthVal.Bind(wx.EVT_KILL_FOCUS,OnWidthChange)
     2516                Indx[widthVal] = i
     2517                widthSizer.Add(widthVal,0,WACV)
     2518                widthRef = wx.CheckBox(layerData,label='Refine?')
     2519                widthRef.SetValue(flags[i])
     2520                Indx[widthRef] = i
     2521                widthRef.Bind(wx.EVT_CHECKBOX, OnRefWidth)
     2522                widthSizer.Add(widthRef,0,WACV)
     2523            return widthSizer
     2524           
     2525        def OnNewLayer(event):
     2526            data['Layers']['Layers'].append({'Name':'Unk','SameAs':'','Symm':'None','Atoms':[]})
     2527            #modify transition probability matrix as well - add new row/column
     2528            UpdateLayerData()
     2529           
     2530        def OnImportLayer(event):
     2531            #from where? DIFFaX files? other phases? NB: transformation issues
     2532            event.Skip()
     2533           
     2534        def LayerSizer(il,Layer):
     2535           
     2536            def OnNameChange(event):
     2537                Layer['Name'] = layerName.GetValue()               
     2538                UpdateLayerData()
     2539               
     2540            def OnAddAtom(event):
     2541                Layer['Atoms'].append(['Unk','Unk','',0.,0.,0.,1.,0.01])
     2542                UpdateLayerData()
     2543               
     2544            def OnSymm(event):
     2545                Layer['Symm'] = symm.GetValue()
     2546           
     2547            def AtomTypeSelect(event):
     2548                r,c =  event.GetRow(),event.GetCol()
     2549                if atomGrid.GetColLabelValue(c) == 'Type':
     2550                    PE = G2elemGUI.PickElement(G2frame)
     2551                    if PE.ShowModal() == wx.ID_OK:
     2552                        if PE.Elem != 'None':                       
     2553                            Layer['Atoms'][r][c] = PE.Elem.strip()
     2554                            name = Layer['Atoms'][r][c]
     2555                            if len(name) in [2,4]:
     2556                                Layer['Atoms'][r][c-1] = name[:2]+'%d'%(r+1)
     2557                            else:
     2558                                Layer['Atoms'][r][c-1] = name[:1]+'%d'%(r+1)
     2559                    PE.Destroy()
     2560                    UpdateLayerData()
     2561                else:
     2562                    event.Skip()
     2563                   
     2564            def OnDrawLayer(event):
     2565                drawLayer.SetValue(False)
     2566                pass
     2567               
     2568            def OnSameAs(event):
     2569                Layer['SameAs'] = sameas.GetValue()
     2570                wx.CallAfter(UpdateLayerData)
     2571                   
     2572            layerSizer = wx.BoxSizer(wx.VERTICAL)
     2573            nameSizer = wx.BoxSizer(wx.HORIZONTAL)           
     2574            nameSizer.Add(wx.StaticText(layerData,label=' Layer name: '),0,WACV)
     2575            layerName = wx.TextCtrl(layerData,value=Layer['Name'],style=wx.TE_PROCESS_ENTER)
     2576            layerName.Bind(wx.EVT_TEXT_ENTER,OnNameChange)       
     2577            layerName.Bind(wx.EVT_KILL_FOCUS,OnNameChange)
     2578            nameSizer.Add(layerName,0,WACV)
     2579            if il:
     2580                nameSizer.Add(wx.StaticText(layerData,label=' Same as: '),0,WACV)
     2581                sameas = wx.ComboBox(layerData,value=Layer['SameAs'],choices=['',]+layerNames[:-1],
     2582                    style=wx.CB_READONLY|wx.CB_DROPDOWN)
     2583                sameas.Bind(wx.EVT_COMBOBOX, OnSameAs)
     2584                nameSizer.Add(sameas,0,WACV)
     2585                if Layer['SameAs']:
     2586                    indx = layerNames.index(Layer['SameAs'])
     2587                    if indx < il:    #previously used : same layer
     2588                        layerSizer.Add(nameSizer)
     2589                        return layerSizer
     2590            nameSizer.Add(wx.StaticText(layerData,label=' Layer symmetry: '),0,WACV)
     2591            symmChoice = ['-1','None']
     2592            symm = wx.ComboBox(layerData,value=Layer['Symm'],choices=symmChoice,
     2593                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     2594            symm.Bind(wx.EVT_COMBOBOX,OnSymm)
     2595            nameSizer.Add(symm,0,WACV)
     2596            addAtom = wx.CheckBox(layerData,label=' Add atom? ')
     2597            addAtom.Bind(wx.EVT_CHECKBOX, OnAddAtom)
     2598            nameSizer.Add(addAtom,0,WACV)
     2599            drawLayer = wx.CheckBox(layerData,label=' Draw layer? ')
     2600            drawLayer.Bind(wx.EVT_CHECKBOX, OnDrawLayer)
     2601            nameSizer.Add(drawLayer,0,WACV)
     2602            layerSizer.Add(nameSizer)
     2603            table = []
     2604            rowLabels = []
     2605            for i,atom in enumerate(Layer['Atoms']):
     2606                table.append(atom)
     2607                rowLabels.append(str(i))
     2608            atomTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=colTypes)
     2609            atomGrid = G2G.GSGrid(layerData)
     2610            atomGrid.SetTable(atomTable,True)
     2611            atomGrid.SetScrollRate(0,0)    #get rid of automatic scroll bars
     2612            for c in range(3,6):
     2613                attr = wx.grid.GridCellAttr()
     2614                attr.IncRef()               #fix from Jim Hester
     2615                attr.SetEditor(G2G.GridFractionEditor(atomGrid))
     2616                atomGrid.SetColAttr(c, attr)
     2617            atomGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, AtomTypeSelect)
     2618            atomGrid.AutoSizeColumns(True)
     2619            layerSizer.Add(atomGrid)
     2620            return layerSizer
     2621           
     2622        def TransSizer():
     2623           
     2624            def PlotSelect(event):
     2625                Obj = event.GetEventObject()
     2626                Yi = Indx[Obj.GetId()]               
     2627                Xi,c =  event.GetRow(),event.GetCol()
     2628                if Xi >= 0 and c == 5:   #plot column
     2629                    Obj.SetCellValue(Xi,5,'')
     2630                    print 'plot %s - %s'%(Names[Yi],Names[Xi])
     2631           
     2632            transSizer = wx.BoxSizer(wx.VERTICAL)
     2633            transSizer.Add(wx.StaticText(layerData,label=' Layer-Layer transition probabilities:'),0,WACV)
     2634            Names = [layer['Name'] for layer in Layers['Layers']]
     2635            transArray = Layers['Transitions']
     2636            Indx = {}
     2637            if not Names or not transArray:
     2638                return transSizer
     2639            for Yi,Yname in enumerate(Names):
     2640                transSizer.Add(wx.StaticText(layerData,label=' From %s to:'%(Yname)),0,WACV)
     2641                table = []
     2642                rowLabels = []
     2643                for Xi,Xname in enumerate(Names):
     2644                    table.append(transArray[Yi][Xi])
     2645                    rowLabels.append(Xname)
     2646                transTable = G2G.Table(table,rowLabels=rowLabels,colLabels=transLabels,types=transTypes)
     2647                transGrid = G2G.GSGrid(layerData)
     2648                transGrid.SetTable(transTable,True)
     2649                transGrid.SetScrollRate(0,0)    #get rid of automatic scroll bars
     2650                Indx[transGrid.GetId()] = Yi
     2651                for c in range(1,4):
     2652                    attr = wx.grid.GridCellAttr()
     2653                    attr.IncRef()               #fix from Jim Hester
     2654                    attr.SetEditor(G2G.GridFractionEditor(transGrid))
     2655                    transGrid.SetColAttr(c, attr)
     2656                transGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, PlotSelect)
     2657                transGrid.AutoSizeColumns(True)
     2658                transSizer.Add(transGrid)
     2659            return transSizer
     2660           
     2661        def StackSizer():
     2662           
     2663            def OnStackType(event):
     2664                Layers['Stacking'][0] = stackType.GetValue()
     2665                wx.CallAfter(UpdateLayerData)
     2666               
     2667            def OnNumLayers(event):
     2668                val = numLayers.GetValue()
     2669                if val == 'infinite':
     2670                    Layers['Stacking'][1] = val
     2671                else:
     2672                    if int(val) > 1032:
     2673                        Layers['Stacking'][1] = 'infinite'
     2674                    else:
     2675                        Layers['Stacking'][1] = val
     2676                numLayers.SetValue(val)
     2677               
     2678            def OnSeqType(event):
     2679                Layers['Stacking'][1] = seqType.GetValue()
     2680           
     2681            stackChoice = ['recursive','explicit',]
     2682            seqChoice = ['random','list',]
     2683            numChoice = [' ','infinite',]           
     2684            stackSizer = wx.BoxSizer(wx.VERTICAL)
     2685            stackSizer.Add(wx.StaticText(layerData,label=' Layer stacking parameters:'),0,WACV)
     2686            if not Layers['Stacking']:
     2687                return stackSizer
     2688            topLine = wx.BoxSizer(wx.HORIZONTAL)
     2689            topLine.Add(wx.StaticText(layerData,label=' Stacking type: '),0,WACV)
     2690            stackType = wx.ComboBox(layerData,value=Layers['Stacking'][0],choices=stackChoice,
     2691                style=wx.CB_READONLY|wx.CB_DROPDOWN)
     2692            stackType.Bind(wx.EVT_COMBOBOX,OnStackType)
     2693            topLine.Add(stackType,0,WACV)
     2694            if Layers['Stacking'][0] == 'recursive':
     2695                topLine.Add(wx.StaticText(layerData,label=' number of layers: '),0,WACV)
     2696                numLayers = wx.ComboBox(layerData,value=Layers['Stacking'][1],choices=numChoice,
     2697                    style=wx.CB_DROPDOWN)
     2698                stackType.Bind(wx.EVT_COMBOBOX,OnNumLayers)
     2699                stackType.Bind(wx.EVT_TEXT_ENTER,OnNumLayers)       
     2700                stackType.Bind(wx.EVT_KILL_FOCUS,OnNumLayers)
     2701                topLine.Add(numLayers,0,WACV)
     2702            elif Layers['Stacking'][0] == 'explicit':
     2703                topLine.Add(wx.StaticText(layerData,label=' layer sequence: '),0,WACV)
     2704                seqType = wx.ComboBox(layerData,value=Layers['Stacking'][1],choices=seqChoice,
     2705                    style=wx.CB_READONLY|wx.CB_DROPDOWN)
     2706                seqType.Bind(wx.EVT_COMBOBOX,OnSeqType)
     2707                topLine.Add(seqType,0,WACV)
     2708            stackSizer.Add(topLine,0,WACV)
     2709            if Layers['Stacking'][1] == 'list':
     2710                stackSizer.Add(wx.StaticText(layerData,label=' Explicit layer sequence;'
     2711               
     2712            return stackSizer
     2713           
     2714        generalData = data['General']
     2715        Layers = data['Layers']
     2716        layerNames = []
     2717        if len(Layers['Layers']):
     2718            layerNames = [layer['Name'] for layer in Layers['Layers']]
     2719        G2frame.dataFrame.SetStatusText('')
     2720        layerData = G2frame.layerData
     2721        SGData = generalData['SGData']
     2722        if layerData.GetSizer():
     2723            layerData.GetSizer().Clear(True)
     2724        mainSizer = wx.BoxSizer(wx.VERTICAL)
     2725        topSizer = wx.BoxSizer(wx.VERTICAL)   
     2726        bottomSizer = wx.BoxSizer(wx.VERTICAL)   
     2727        topSizer.Add(wx.StaticText(layerData,label=' Global layer description:'),0,WACV)
     2728        laueSizer = wx.BoxSizer(wx.HORIZONTAL)
     2729        laueSizer.Add(wx.StaticText(layerData,label=' Diffraction Laue symmetry:'),0,WACV)
     2730        laue = wx.ComboBox(layerData,value=Layers['Laue'],choices=laueChoice,
     2731            style=wx.CB_READONLY|wx.CB_DROPDOWN)
     2732        laue.Bind(wx.EVT_COMBOBOX,OnLaue)
     2733        laueSizer.Add(laue,0,WACV)
     2734        if Layers['Laue'] == 'unknown':
     2735            laueSizer.Add(wx.StaticText(layerData,label=' Diffraction symmetry tolerance: '),0,WACV)
     2736            toler = wx.TextCtrl(layerData,value='%.3f'%(Layers['Toler']),style=wx.TE_PROCESS_ENTER)
     2737            toler.Bind(wx.EVT_TEXT_ENTER,OnToler)       
     2738            toler.Bind(wx.EVT_KILL_FOCUS,OnToler)
     2739            laueSizer.Add(toler,0,WACV)
     2740        topSizer.Add(laueSizer,0,WACV)
     2741        topSizer.Add(wx.StaticText(layerData,label=' Reference unit cell for all layers:'),0,WACV)
     2742        topSizer.Add(CellSizer(),0,WACV)
     2743        topSizer.Add(WidthSizer())
     2744        G2G.HorizontalLine(topSizer,layerData)
     2745        titleSizer = wx.BoxSizer(wx.HORIZONTAL)
     2746        titleSizer.Add(wx.StaticText(layerData,label=' Layer descriptions: '),0,WACV)
     2747        newLayer = wx.CheckBox(layerData,label=' Add new layer?')
     2748        newLayer.Bind(wx.EVT_CHECKBOX, OnNewLayer)
     2749        titleSizer.Add(newLayer,0,WACV)
     2750        importLayer = wx.CheckBox(layerData,label=' Import new layer?')
     2751        importLayer.Bind(wx.EVT_CHECKBOX, OnImportLayer)
     2752        titleSizer.Add(importLayer,0,WACV)
     2753        topSizer.Add(titleSizer,0,WACV)
     2754        for il,layer in enumerate(Layers['Layers']):
     2755            topSizer.Add(LayerSizer(il,layer))
     2756        mainSizer.Add(topSizer)
     2757        G2G.HorizontalLine(bottomSizer,layerData)
     2758        bottomSizer.Add(TransSizer())
     2759        G2G.HorizontalLine(bottomSizer,layerData)
     2760        bottomSizer.Add(StackSizer())
     2761        mainSizer.Add(bottomSizer)
     2762        SetPhaseWindow(G2frame.dataFrame,G2frame.layerData,mainSizer,Scroll)
     2763       
     2764    def OnLoadDIFFaX(event):
     2765        if len(data['Layers']['Layers']):
     2766            dlg = wx.MessageDialog(G2frame,'Do you really want to replace the Layer data?','Load DIFFaX file',
     2767                wx.YES_NO | wx.ICON_QUESTION)
     2768            try:
     2769                result = dlg.ShowModal()
     2770                if result == wx.ID_NO:
     2771                    return
     2772            finally:
     2773                dlg.Destroy()
     2774        dlg = wx.FileDialog(G2frame, 'Choose DIFFaX file name to read', '.', '',
     2775            'DIFFaX file (*.*)|*.*',style=wx.OPEN | wx.CHANGE_DIR)
     2776        try:
     2777            if dlg.ShowModal() == wx.ID_OK:
     2778                DIFFaXfile = dlg.GetPath()
     2779                data['Layers'] = G2IO.ReadDIFFaX(DIFFaXfile)
     2780        finally:
     2781            dlg.Destroy()
     2782        wx.CallAfter(UpdateLayerData)
     2783       
     2784################################################################################
    23622785#### Wave Data page
    23632786################################################################################
     
    23942817        for atm in atomData:
    23952818            atNames.append(atm[ct-1])
     2819        if not atNames:
     2820            return
    23962821        if G2frame.atmSel not in atNames:
    23972822            G2frame.atmSel = atNames[0]
     
    46575082        AtLookUp = G2mth.FillAtomLookUp(data['Atoms'],cia+8)
    46585083        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
    4659         RBData = G2frame.PatternTree.GetItemPyData(   
    4660             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     5084        Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies')
     5085        if not Id:
     5086            return
     5087        RBData = G2frame.PatternTree.GetItemPyData(Id)
    46615088        Indx = {}
    46625089        atomStyle = 'balls & sticks'
     
    55265953        general = data['General']
    55275954        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
    5528         RBData = G2frame.PatternTree.GetItemPyData(   
    5529             G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     5955        Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies')
     5956        if not Id:
     5957            return
     5958        RBData = G2frame.PatternTree.GetItemPyData(Id)
    55305959        Indx = {}
    55315960        atomStyle = 'balls & sticks'
     
    63866815            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.AtomsMenu)
    63876816            FillAtomsGrid(Atoms)
     6817        elif text == 'Layers':
     6818            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LayerData)
     6819            UpdateLayerData()
    63886820        elif text == 'Wave Data' and data['General']['Type'] in ['modulated','magnetic']:
    63896821            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.WavesData)
     
    64686900        if data['General']['Type'] in ['modulated','magnetic']:
    64696901            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.WavesData)
    6470             G2frame.dataFrame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)           
     6902            G2frame.dataFrame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
     6903        # Stacking faults
     6904        if data['General']['Type'] == 'faulted':
     6905            print 'set bind'
     6906            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.LayerData)
     6907            G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
    64716908        # Draw Options
    64726909        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.DataDrawOptions)
     
    65647001        G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    65657002        G2frame.dataDisplay.AddPage(G2frame.waveData,'Wave Data')
    6566         Pages.append('Wave Data')       
     7003        Pages.append('Wave Data')
     7004    if data['General']['Type'] == 'faulted':
     7005        G2frame.layerData = wx.ScrolledWindow(G2frame.dataDisplay)
     7006        G2frame.dataDisplay.AddPage(G2frame.layerData,'Layers')
     7007        Pages.append('Layers')               
    65677008    drawOptions = wx.ScrolledWindow(G2frame.dataDisplay)
    65687009    G2frame.dataDisplay.AddPage(drawOptions,'Draw Options')
     
    65727013    G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
    65737014    Pages.append('Draw Atoms')
    6574     RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
    6575     G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
    6576     Pages.append('RB Models')
     7015    if data['General']['Type'] not in ['modulated','magnetic','faulted',]:
     7016        RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
     7017        G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
     7018        Pages.append('RB Models')
    65777019    MapPeaks = G2G.GSGrid(G2frame.dataDisplay)
    65787020    G2frame.dataDisplay.gridList.append(MapPeaks)   
    65797021    G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
    65807022    Pages.append('Map peaks')
    6581     if data['General']['Type'] not in ['modulated','magnetic']:
     7023    if data['General']['Type'] not in ['modulated','magnetic','faulted',]:
    65827024        G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
    65837025        G2frame.dataDisplay.AddPage(G2frame.MCSA,'MC/SA')
  • trunk/imports/G2pwd_FP.py

    r2159 r2161  
    9595                # valid line to read
    9696                if not steps:
    97                     print S
    9897                    vals = S.split(None,4)
    99                     print vals
    10098                    if len(vals) >= 3:
    10199                        steps = True
Note: See TracChangeset for help on using the changeset viewer.