Changeset 2161 for trunk/GSASIIphsGUI.py


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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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')
Note: See TracChangeset for help on using the changeset viewer.