Changeset 848


Ignore:
Timestamp:
Feb 7, 2013 10:43:11 AM (9 years ago)
Author:
vondreele
Message:

move all class stuff in GSAIIphsGUI to GSASIIgrid.py
move all DData GUI stuff to GSASIIddataGUI.py - new module
more rigid body work

Location:
trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIIO.py

    r846 r848  
    755755        'Histograms':{},
    756756        'Pawley ref':[],
    757         'Models':{},
     757        'RBModels':{},
    758758        }
    759759    return phaseData
  • trunk/GSASIIconstrGUI.py

    r842 r848  
    2020import GSASIIElem as G2elem
    2121import GSASIIElemGUI as G2elemGUI
    22 import GSASIIphsGUI as G2phG
    2322import GSASIIstruct as G2str
    2423import GSASIImapvars as G2mv
     
    879878            rbData['rbSeq'].append([Orig,Piv,0.0,Riding])           
    880879        dlg.Destroy()
    881         UpdateResidueRB()       
     880        UpdateResidueRB()
     881       
    882882
    883883    def AddZMatrixRB():
     
    10061006                vecGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, TypeSelect)
    10071007            attr = wx.grid.GridCellAttr()
    1008             attr.SetEditor(G2phG.GridFractionEditor(vecGrid))
     1008            attr.SetEditor(G2gd.GridFractionEditor(vecGrid))
    10091009            for c in range(3):
    10101010                vecGrid.SetColAttr(c, attr)
     
    11251125            vecGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, TypeSelect)
    11261126            attr = wx.grid.GridCellAttr()
    1127             attr.SetEditor(G2phG.GridFractionEditor(vecGrid))
     1127            attr.SetEditor(G2gd.GridFractionEditor(vecGrid))
    11281128            for c in range(3):
    11291129                vecGrid.SetColAttr(c, attr)
    11301130            for row in range(vecTable.GetNumberRows()):
    1131                 for col in [4,5,6]:
     1131                for col in range(5):
    11321132                    vecGrid.SetCellStyle(row,col,VERY_LIGHT_GREY,True)
    11331133            vecGrid.SetMargins(0,0)
     
    11521152            def OnRadBtn(event):
    11531153                Obj = event.GetEventObject()
    1154                 Seq,iSeq,ang = Indx[Obj.GetId()]
    1155                 data['Residue'][rbId]['SelSeq'] = [iSeq,ang]
     1154                Seq,iSeq,angId = Indx[Obj.GetId()]
     1155                data['Residue'][rbId]['SelSeq'] = [iSeq,angId]
    11561156                angSlide.SetValue(int(100*Seq[2]))
    11571157           
     
    11621162            if not iSeq:
    11631163                radBt = wx.RadioButton(ResidueRBDisplay,-1,'',style=wx.RB_GROUP)
    1164                 data['Residue'][rbId]['SelSeq'] = [iSeq,ang]
     1164                data['Residue'][rbId]['SelSeq'] = [iSeq,ang.GetId()]
    11651165            else:
    11661166                radBt = wx.RadioButton(ResidueRBDisplay,-1,'')
     
    11691169            bond = wx.TextCtrl(ResidueRBDisplay,-1,'%s %s'%(atNames[iBeg],atNames[iFin]),size=(50,20))
    11701170            seqSizer.Add(bond,0,wx.ALIGN_CENTER_VERTICAL)
    1171             Indx[radBt.GetId()] = [Seq,iSeq,ang]
    1172             Indx[ang.GetId()] = [rbId,Seq]
     1171            Indx[radBt.GetId()] = [Seq,iSeq,ang.GetId()]
     1172            Indx[ang.GetId()] = [rbId,Seq,ang]
    11731173            ang.Bind(wx.EVT_TEXT_ENTER,ChangeAngle)
    11741174            ang.Bind(wx.EVT_KILL_FOCUS,ChangeAngle)
     
    11861186                Obj = event.GetEventObject()
    11871187                rbData = Indx[Obj.GetId()]
    1188                 iSeq,ang = rbData['SelSeq']
     1188                iSeq,angId = rbData['SelSeq']
    11891189                val = float(Obj.GetValue())/100.
    11901190                rbData['rbSeq'][iSeq][2] = val
    1191                 ang.SetValue('%8.2f'%(val))
     1191                Indx[angId][2].SetValue('%8.2f'%(val))
    11921192                G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,rbData,plotDefaults)
    11931193           
    11941194            slideSizer = wx.BoxSizer(wx.HORIZONTAL)
    11951195            slideSizer.Add(wx.StaticText(ResidueRBDisplay,-1,'Selected torsion angle:'),0)
    1196             iSeq,ang = rbData['SelSeq']
     1196            iSeq,angId = rbData['SelSeq']
    11971197            angSlide = wx.Slider(ResidueRBDisplay,-1,
    11981198                int(100*rbData['rbSeq'][iSeq][2]),0,36000,size=(200,20),
     
    12271227            if rbData['rbSeq']:
    12281228                ResidueRBSizer.Add(slideSizer,)
     1229            ResidueRBSizer.Add(wx.StaticText(ResidueRBDisplay,-1,100*'-'))
     1230
    12291231        ResidueRBSizer.Add((5,25),)
    12301232        ResidueRBSizer.Layout()   
  • trunk/GSASIIgrid.py

    r843 r848  
    5454[ wxID_ATOMSEDITADD, wxID_ATOMSEDITINSERT, wxID_ATOMSEDITDELETE, wxID_ATOMSREFINE,
    5555    wxID_ATOMSMODIFY, wxID_ATOMSTRANSFORM, wxID_ATOMSVIEWADD, wxID_ATOMVIEWINSERT,
    56     wxID_RELOADDRAWATOMS,wxID_ATOMSDISAGL,wxID_ATOMMOVE,
    57 ] = [wx.NewId() for item in range(11)]
     56    wxID_RELOADDRAWATOMS,wxID_ATOMSDISAGL,wxID_ATOMMOVE,wxID_RBAPPEND,
     57    wxID_ASSIGNATMS2RB
     58] = [wx.NewId() for item in range(13)]
    5859
    5960[ wxID_DRAWATOMSTYLE, wxID_DRAWATOMLABEL, wxID_DRAWATOMCOLOR, wxID_DRAWATOMRESETCOLOR,
     
    105106
    106107[ wxID_RIGIDBODYADD,wxID_DRAWDEFINERB,wxID_RIGIDBODYIMPORT,wxID_RESIDUETORSSEQ,
    107     wxID_ZMATRIXADD,
    108 ] = [wx.NewId() for item in range(5)]
     108    wxID_ZMATRIXADD,wxID_AUTOFINDRESRB,wxID_GLOBALRESREFINE
     109] = [wx.NewId() for item in range(7)]
    109110
    110111[ wxID_SAVESEQSEL,
     
    120121VERY_LIGHT_GREY = wx.Colour(235,235,235)
    121122
    122 def ShowHelp(helpType,frame):
    123     '''Called to bring up a web page for documentation.'''
    124     global htmlFirstUse
    125     # look up a definition for help info from dict
    126     helplink = helpLocDict.get(helpType)
    127     if helplink is None:
    128         # no defined link to use, create a default based on key
    129         helplink = 'gsasII.html#'+helpType.replace(' ','_')
    130     helplink = os.path.join(path2GSAS2,'help',helplink)
    131     if helpMode == 'internal':
     123################################################################################
     124#### GSAS-II class definitions
     125################################################################################
     126
     127class SymOpDialog(wx.Dialog):
     128    def __init__(self,parent,SGData,New=True,ForceUnit=False):
     129        wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
     130            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     131        panel = wx.Panel(self)
     132        self.SGData = SGData
     133        self.New = New
     134        self.Force = ForceUnit
     135        self.OpSelected = [0,0,0,[0,0,0],False,False]
     136        mainSizer = wx.BoxSizer(wx.VERTICAL)
     137        if ForceUnit:
     138            choice = ['No','Yes']
     139            self.force = wx.RadioBox(panel,-1,'Force to unit cell?',choices=choice)
     140            self.force.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     141            mainSizer.Add(self.force,0,wx.ALIGN_CENTER_VERTICAL)
     142        mainSizer.Add((5,5),0)
     143        if SGData['SGInv']:
     144            choice = ['No','Yes']
     145            self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
     146            self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     147            mainSizer.Add(self.inv,0,wx.ALIGN_CENTER_VERTICAL)
     148        mainSizer.Add((5,5),0)
     149        if SGData['SGLatt'] != 'P':
     150            LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
     151            self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
     152            self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     153            mainSizer.Add(self.latt,0,wx.ALIGN_CENTER_VERTICAL)
     154        mainSizer.Add((5,5),0)
     155        if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
     156            Ncol = 2
     157        else:
     158            Ncol = 3
     159        OpList = []
     160        for M,T in SGData['SGOps']:
     161            OpList.append(G2spc.MT2text(M,T))
     162        self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
     163            majorDimension=Ncol)
     164        self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     165        mainSizer.Add(self.oprs,0,wx.ALIGN_CENTER_VERTICAL)
     166        mainSizer.Add((5,5),0)
     167        mainSizer.Add(wx.StaticText(panel,-1,"   Choose unit cell?"),0,wx.ALIGN_CENTER_VERTICAL)
     168        mainSizer.Add((5,5),0)
     169        cellSizer = wx.BoxSizer(wx.HORIZONTAL)
     170        cellSizer.Add((5,0),0)
     171        cellName = ['X','Y','Z']
     172        self.cell = []
     173        for i in range(3):
     174            self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
     175            self.cell[-1].SetRange(-3,3)
     176            self.cell[-1].SetValue(0)
     177            self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
     178            cellSizer.Add(self.cell[-1],0,wx.ALIGN_CENTER_VERTICAL)
     179        mainSizer.Add(cellSizer,0,)
     180        if self.New:
     181            choice = ['No','Yes']
     182            self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
     183            self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
     184            mainSizer.Add(self.new,0,wx.ALIGN_CENTER_VERTICAL)
     185        mainSizer.Add((5,5),0)
     186
     187        OkBtn = wx.Button(panel,-1,"Ok")
     188        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     189        cancelBtn = wx.Button(panel,-1,"Cancel")
     190        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     191        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     192        btnSizer.Add((20,20),1)
     193        btnSizer.Add(OkBtn)
     194        btnSizer.Add((20,20),1)
     195        btnSizer.Add(cancelBtn)
     196        btnSizer.Add((20,20),1)
     197
     198        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     199        panel.SetSizer(mainSizer)
     200        panel.Fit()
     201        self.Fit()
     202
     203    def OnOpSelect(self,event):
     204        if self.SGData['SGInv']:
     205            self.OpSelected[0] = self.inv.GetSelection()
     206        if self.SGData['SGLatt'] != 'P':
     207            self.OpSelected[1] = self.latt.GetSelection()
     208        self.OpSelected[2] = self.oprs.GetSelection()
     209        for i in range(3):
     210            self.OpSelected[3][i] = float(self.cell[i].GetValue())
     211        if self.New:
     212            self.OpSelected[4] = self.new.GetSelection()
     213        if self.Force:
     214            self.OpSelected[5] = self.force.GetSelection()
     215
     216    def GetSelection(self):
     217        return self.OpSelected
     218
     219    def OnOk(self,event):
     220        parent = self.GetParent()
     221        parent.Raise()
     222        self.EndModal(wx.ID_OK)
     223
     224    def OnCancel(self,event):
     225        parent = self.GetParent()
     226        parent.Raise()
     227        self.EndModal(wx.ID_CANCEL)
     228
     229class DisAglDialog(wx.Dialog):
     230   
     231    def __default__(self,data,default):
     232        if data:
     233            self.data = data
     234        else:
     235            self.data = {}
     236            self.data['Name'] = default['Name']
     237            self.data['Factors'] = [0.85,0.85]
     238            self.data['AtomTypes'] = default['AtomTypes']
     239            self.data['BondRadii'] = default['BondRadii']
     240            self.data['AngleRadii'] = default['AngleRadii']
     241       
     242    def __init__(self,parent,data,default):
     243        wx.Dialog.__init__(self,parent,-1,'Distance Angle Controls',
     244            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     245        self.default = default
     246        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     247        self.__default__(data,self.default)
     248        self.Draw(self.data)
     249               
     250    def Draw(self,data):
     251        self.panel.Destroy()
     252        self.panel = wx.Panel(self)
     253        mainSizer = wx.BoxSizer(wx.VERTICAL)
     254        mainSizer.Add(wx.StaticText(self.panel,-1,'Controls for phase '+data['Name']),
     255            0,wx.ALIGN_CENTER_VERTICAL|wx.LEFT,10)
     256        mainSizer.Add((10,10),1)
     257       
     258        radiiSizer = wx.FlexGridSizer(2,3,5,5)
     259        radiiSizer.Add(wx.StaticText(self.panel,-1,' Type'),0,wx.ALIGN_CENTER_VERTICAL)
     260        radiiSizer.Add(wx.StaticText(self.panel,-1,'Bond radii'),0,wx.ALIGN_CENTER_VERTICAL)
     261        radiiSizer.Add(wx.StaticText(self.panel,-1,'Angle radii'),0,wx.ALIGN_CENTER_VERTICAL)
     262        self.objList = {}
     263        for id,item in enumerate(self.data['AtomTypes']):
     264            radiiSizer.Add(wx.StaticText(self.panel,-1,' '+item),0,wx.ALIGN_CENTER_VERTICAL)
     265            bRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['BondRadii'][id]),style=wx.TE_PROCESS_ENTER)
     266            self.objList[bRadii.GetId()] = ['BondRadii',id]
     267            bRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
     268            bRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
     269            radiiSizer.Add(bRadii,0,wx.ALIGN_CENTER_VERTICAL)
     270            aRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['AngleRadii'][id]),style=wx.TE_PROCESS_ENTER)
     271            self.objList[aRadii.GetId()] = ['AngleRadii',id]
     272            aRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
     273            aRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
     274            radiiSizer.Add(aRadii,0,wx.ALIGN_CENTER_VERTICAL)
     275        mainSizer.Add(radiiSizer,0,wx.EXPAND)
     276        factorSizer = wx.FlexGridSizer(2,2,5,5)
     277        Names = ['Bond','Angle']
     278        for i,name in enumerate(Names):
     279            factorSizer.Add(wx.StaticText(self.panel,-1,name+' search factor'),0,wx.ALIGN_CENTER_VERTICAL)
     280            bondFact = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['Factors'][i]),style=wx.TE_PROCESS_ENTER)
     281            self.objList[bondFact.GetId()] = ['Factors',i]
     282            bondFact.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
     283            bondFact.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
     284            factorSizer.Add(bondFact)
     285        mainSizer.Add(factorSizer,0,wx.EXPAND)
     286       
     287        OkBtn = wx.Button(self.panel,-1,"Ok")
     288        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     289        ResetBtn = wx.Button(self.panel,-1,'Reset')
     290        ResetBtn.Bind(wx.EVT_BUTTON, self.OnReset)
     291        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     292        btnSizer.Add((20,20),1)
     293        btnSizer.Add(OkBtn)
     294        btnSizer.Add(ResetBtn)
     295        btnSizer.Add((20,20),1)
     296        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     297        self.panel.SetSizer(mainSizer)
     298        self.panel.Fit()
     299        self.Fit()
     300   
     301    def OnRadiiVal(self,event):
     302        Obj = event.GetEventObject()
     303        item = self.objList[Obj.GetId()]
    132304        try:
    133             htmlPanel.LoadFile(helplink)
    134             htmlFrame.Raise()
    135         except:
    136             htmlFrame = wx.Frame(frame, -1, size=(610, 510))
    137             htmlFrame.Show(True)
    138             htmlFrame.SetTitle("HTML Window") # N.B. reset later in LoadFile
    139             htmlPanel = MyHtmlPanel(htmlFrame,-1)
    140             htmlPanel.LoadFile(helplink)
    141     else:
    142         pfx = "file://"
    143         if sys.platform.lower().startswith('win'):
    144             pfx = ''
    145         if htmlFirstUse:
    146             webbrowser.open_new(pfx+helplink)
    147             htmlFirstUse = False
     305            self.data[item[0]][item[1]] = float(Obj.GetValue())
     306        except ValueError:
     307            pass
     308        Obj.SetValue("%.3f"%(self.data[item[0]][item[1]]))          #reset in case of error
     309       
     310    def GetData(self):
     311        return self.data
     312       
     313    def OnOk(self,event):
     314        parent = self.GetParent()
     315        parent.Raise()
     316        self.EndModal(wx.ID_OK)             
     317       
     318    def OnReset(self,event):
     319        data = {}
     320        self.__default__(data,self.default)
     321        self.Draw(self.data)
     322       
     323class SingleFloatDialog(wx.Dialog):
     324   
     325    def __init__(self,parent,title,prompt,value,limits=[0.,1.],format='%.5g'):
     326        wx.Dialog.__init__(self,parent,-1,title,
     327            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     328        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
     329        self.limits = limits
     330        self.value = value
     331        self.prompt = prompt
     332        self.format = format
     333        self.Draw()
     334       
     335    def Draw(self):
     336       
     337        def OnValItem(event):
     338            try:
     339                val = float(valItem.GetValue())
     340                if val < self.limits[0] or val > self.limits[1]:
     341                    raise ValueError
     342            except ValueError:
     343                val = self.value
     344            self.value = val
     345            valItem.SetValue(self.format%(self.value))
     346           
     347        self.panel.Destroy()
     348        self.panel = wx.Panel(self)
     349        mainSizer = wx.BoxSizer(wx.VERTICAL)
     350        mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
     351        valItem = wx.TextCtrl(self.panel,-1,value=self.format%(self.value),style=wx.TE_PROCESS_ENTER)
     352        mainSizer.Add(valItem,0,wx.ALIGN_CENTER)
     353        valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
     354        valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
     355        OkBtn = wx.Button(self.panel,-1,"Ok")
     356        OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
     357        CancelBtn = wx.Button(self.panel,-1,'Cancel')
     358        CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
     359        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
     360        btnSizer.Add((20,20),1)
     361        btnSizer.Add(OkBtn)
     362        btnSizer.Add(CancelBtn)
     363        btnSizer.Add((20,20),1)
     364        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
     365        self.panel.SetSizer(mainSizer)
     366        self.panel.Fit()
     367        self.Fit()
     368
     369    def GetValue(self):
     370        return self.value
     371       
     372    def OnOk(self,event):
     373        parent = self.GetParent()
     374        parent.Raise()
     375        self.EndModal(wx.ID_OK)             
     376       
     377    def OnCancel(self,event):
     378        parent = self.GetParent()
     379        parent.Raise()
     380        self.EndModal(wx.ID_CANCEL)
     381       
     382class GridFractionEditor(wg.PyGridCellEditor):
     383    def __init__(self,grid):
     384        wg.PyGridCellEditor.__init__(self)
     385
     386    def Create(self, parent, id, evtHandler):
     387        self._tc = wx.TextCtrl(parent, id, "")
     388        self._tc.SetInsertionPoint(0)
     389        self.SetControl(self._tc)
     390
     391        if evtHandler:
     392            self._tc.PushEventHandler(evtHandler)
     393
     394        self._tc.Bind(wx.EVT_CHAR, self.OnChar)
     395
     396    def SetSize(self, rect):
     397        self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
     398                               wx.SIZE_ALLOW_MINUS_ONE)
     399
     400    def BeginEdit(self, row, col, grid):
     401        self.startValue = grid.GetTable().GetValue(row, col)
     402        self._tc.SetValue(str(self.startValue))
     403        self._tc.SetInsertionPointEnd()
     404        self._tc.SetFocus()
     405        self._tc.SetSelection(0, self._tc.GetLastPosition())
     406
     407    def EndEdit(self, row, col, grid):
     408        changed = False
     409
     410        val = self._tc.GetValue().lower()
     411       
     412        if val != self.startValue:
     413            changed = True
     414            neg = False
     415            if '-' in val:
     416                neg = True
     417            if '/' in val and '.' not in val:
     418                val += '.'
     419            elif 's' in val and not 'sind(' in val:
     420                if neg:
     421                    val = '-sind('+val.strip('-s')+')'
     422                else:
     423                    val = 'sind('+val.strip('s')+')'
     424            elif 'c' in val and not 'cosd(' in val:
     425                if neg:
     426                    val = '-cosd('+val.strip('-c')+')'
     427                else:
     428                    val = 'cosd('+val.strip('c')+')'
     429            try:
     430                val = float(eval(val))
     431            except (SyntaxError,NameError):
     432                val = self.startValue
     433            grid.GetTable().SetValue(row, col, val) # update the table
     434
     435        self.startValue = ''
     436        self._tc.SetValue('')
     437        return changed
     438
     439    def Reset(self):
     440        self._tc.SetValue(self.startValue)
     441        self._tc.SetInsertionPointEnd()
     442
     443    def Clone(self):
     444        return GridFractionEditor(grid)
     445
     446    def StartingKey(self, evt):
     447        self.OnChar(evt)
     448        if evt.GetSkipped():
     449            self._tc.EmulateKeyPress(evt)
     450
     451    def OnChar(self, evt):
     452        key = evt.GetKeyCode()
     453        if key == 15:
     454            return
     455        if key > 255:
     456            evt.Skip()
     457            return
     458        char = chr(key)
     459        if char in '.+-/0123456789cosind()':
     460            self._tc.WriteText(char)
    148461        else:
    149             webbrowser.open(pfx+helplink, new=0, autoraise=True)
     462            evt.Skip()
    150463
    151464class MyHelp(wx.Menu):
     
    7431056        self.AtomEdit.Append(id=wxID_ATOMSVIEWADD, kind=wx.ITEM_NORMAL,text='Append view point',
    7441057            help='Appended as an H atom')
     1058        self.AtomEdit.Append(id=wxID_RBAPPEND, kind=wx.ITEM_NORMAL,text='Append rigid body',
     1059            help='Append atoms for rigid body')
    7451060        self.AtomEdit.Append(id=wxID_ATOMSEDITINSERT, kind=wx.ITEM_NORMAL,text='Insert atom',
    7461061            help='Select atom row to insert before; inserted as an H atom')
    7471062        self.AtomEdit.Append(id=wxID_ATOMVIEWINSERT, kind=wx.ITEM_NORMAL,text='Insert view point',
    7481063            help='Select atom row to insert before; inserted as an H atom')
     1064        self.AtomEdit.Append(id=wxID_ASSIGNATMS2RB, kind=wx.ITEM_NORMAL,text='Assign atoms to rigid body',
     1065            help='Select atom row to start assignment')
    7491066        self.AtomEdit.Append(id=wxID_ATOMMOVE, kind=wx.ITEM_NORMAL,text='Move atom to view point',
    7501067            help='Select single atom to move')
     
    8731190        self.RigidBodiesEdit = wx.Menu(title='')
    8741191        self.RigidBodiesMenu.Append(menu=self.RigidBodiesEdit, title='Edit')
     1192        self.RigidBodiesEdit.Append(id=wxID_AUTOFINDRESRB, kind=wx.ITEM_NORMAL,text='Auto find residues',
     1193            help='Auto find of residue RBs in macromolecule')
     1194        self.RigidBodiesEdit.Append(id=wxID_GLOBALRESREFINE, kind=wx.ITEM_NORMAL,text='Global residue refine',
     1195            help='Global setting of residue RB refinement flags')
    8751196
    8761197        self.PostfillDataMenu()
     
    10831404                self.data[row][col] = value
    10841405        innerSetValue(row, col, value)
     1406       
     1407################################################################################
     1408#### Help
     1409################################################################################
     1410
     1411def ShowHelp(helpType,frame):
     1412    '''Called to bring up a web page for documentation.'''
     1413    global htmlFirstUse
     1414    # look up a definition for help info from dict
     1415    helplink = helpLocDict.get(helpType)
     1416    if helplink is None:
     1417        # no defined link to use, create a default based on key
     1418        helplink = 'gsasII.html#'+helpType.replace(' ','_')
     1419    helplink = os.path.join(path2GSAS2,'help',helplink)
     1420    if helpMode == 'internal':
     1421        try:
     1422            htmlPanel.LoadFile(helplink)
     1423            htmlFrame.Raise()
     1424        except:
     1425            htmlFrame = wx.Frame(frame, -1, size=(610, 510))
     1426            htmlFrame.Show(True)
     1427            htmlFrame.SetTitle("HTML Window") # N.B. reset later in LoadFile
     1428            htmlPanel = MyHtmlPanel(htmlFrame,-1)
     1429            htmlPanel.LoadFile(helplink)
     1430    else:
     1431        pfx = "file://"
     1432        if sys.platform.lower().startswith('win'):
     1433            pfx = ''
     1434        if htmlFirstUse:
     1435            webbrowser.open_new(pfx+helplink)
     1436            htmlFirstUse = False
     1437        else:
     1438            webbrowser.open(pfx+helplink, new=0, autoraise=True)
    10851439
    10861440################################################################################
     
    12831637            'histNames' - list of histogram names in order as processed by Sequential Refinement
    12841638            'varyList' - list of variables - identical over all refinements insequence
    1285             histName - dictionaries for all data sets processed:
     1639            'histName' - dictionaries for all data sets processed:
    12861640                'variables'- result[0] from leastsq call
    12871641                'varyList' - list of variables; same as above
  • trunk/GSASIImath.py

    r826 r848  
    12031203    except KeyError:
    12041204        return Parms['Lam1'][1]
     1205
     1206def UpdateResRBAtoms(Amat,Bmat,Atoms,AtLookUp,RBObj,RBData):
     1207    RBIds = GetResRBIds(RBData)
     1208    RBRes = RBData[RBIds[RBObj['ResName']]]
     1209    XYZ = np.array(RBRes['rbXYZ'])
     1210    for tor,seq in zip(RBObj['Torsions'],RBRes['rbSeq']):
     1211        QuatA = AVdeg2Q(tor[0],XYZ[seq[0]]-XYZ[seq[1]])
     1212        for ride in seq[3]:
     1213            VB = prodQVQ(QuatA,XYZ[ride]-XYZ[seq[1]])
     1214            XYZ[ride] += VB
     1215    for i,xyz in enumerate(XYZ):
     1216        xyz = prodQVQ(RBObj['Orient'][0],xyz)
     1217        xyz = np.inner(Bmat,xyz)
     1218        xyz += RBObj['Orig'][0]
     1219        XYZ[i] = xyz
     1220    Atxyz = GetAtomsById(Atoms,AtLookUp,RBObj['Ids'])
     1221   
     1222def GetResRBIds(RBData):   
     1223    rbKeys = RBData.keys()
     1224    rbKeys.remove('AtInfo')
     1225    if not len(rbKeys):
     1226        return {}
     1227    RBNames = [RBData[k]['RBname'] for k in rbKeys]
     1228    return dict(zip(RBNames,rbKeys))
     1229   
    12051230   
    12061231def prodQQ(QA,QB):
     
    12981323    Q[1:4] = V*S
    12991324    return Q
    1300    
     1325
     1326def makeQuat(A,B,C):
     1327    ''' Make quaternion from rotation of A vector to B vector about C axis
     1328        A,B,C are np.array Cartesian 3-vectors
     1329    Returns quaternion & rotation angle in radians
     1330    '''
     1331
     1332    V1 = np.cross(A,C)
     1333    V2 = np.cross(B,C)
     1334    if nl.norm(V1)*nl.norm(V2):
     1335        V1 /= nl.norm(V1)
     1336        V2 /= nl.norm(V2)
     1337        V3 = np.cross(V1,V2)
     1338    else:
     1339        v3 = np.zero(3)
     1340    Q = np.array([1.0,0.0,0.0,0.0])
     1341    D = 0.
     1342    if nl.norm(V3):
     1343        V3 /= nl.norm(V3)
     1344        D1 = min(1.0,max(-1.0,np.vdot(V1,V2)))
     1345        D = np.arccos(D1)/2.0
     1346        V1 = C-V3
     1347        V2 = C+V3
     1348        DM = nl.norm(V1)
     1349        DP = nl.norm(V2)
     1350        S = np.sin(D)
     1351        Q[0] = np.cos(D)
     1352        Q[1:] = V3*S
     1353        D *= 2.
     1354        if DM > DP:
     1355            D *= -1.
     1356    return Q,D
     1357   
  • trunk/GSASIIphsGUI.py

    r844 r848  
    2424import GSASIIElem as G2elem
    2525import GSASIIElemGUI as G2elemGUI
     26import GSASIIddataGUI as G2ddG
    2627import GSASIIplot as G2plt
    2728import GSASIIgrid as G2gd
     
    4647acosd = lambda x: 180.*np.arccos(x)/np.pi
    4748
    48 class SymOpDialog(wx.Dialog):
    49     def __init__(self,parent,SGData,New=True,ForceUnit=False):
    50         wx.Dialog.__init__(self,parent,-1,'Select symmetry operator',
    51             pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
    52         panel = wx.Panel(self)
    53         self.SGData = SGData
    54         self.New = New
    55         self.Force = ForceUnit
    56         self.OpSelected = [0,0,0,[0,0,0],False,False]
    57         mainSizer = wx.BoxSizer(wx.VERTICAL)
    58         if ForceUnit:
    59             choice = ['No','Yes']
    60             self.force = wx.RadioBox(panel,-1,'Force to unit cell?',choices=choice)
    61             self.force.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
    62             mainSizer.Add(self.force,0,wx.ALIGN_CENTER_VERTICAL)
    63         mainSizer.Add((5,5),0)
    64         if SGData['SGInv']:
    65             choice = ['No','Yes']
    66             self.inv = wx.RadioBox(panel,-1,'Choose inversion?',choices=choice)
    67             self.inv.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
    68             mainSizer.Add(self.inv,0,wx.ALIGN_CENTER_VERTICAL)
    69         mainSizer.Add((5,5),0)
    70         if SGData['SGLatt'] != 'P':
    71             LattOp = G2spc.Latt2text(SGData['SGLatt']).split(';')
    72             self.latt = wx.RadioBox(panel,-1,'Choose cell centering?',choices=LattOp)
    73             self.latt.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
    74             mainSizer.Add(self.latt,0,wx.ALIGN_CENTER_VERTICAL)
    75         mainSizer.Add((5,5),0)
    76         if SGData['SGLaue'] in ['-1','2/m','mmm','4/m','4/mmm']:
    77             Ncol = 2
    78         else:
    79             Ncol = 3
    80         OpList = []
    81         for M,T in SGData['SGOps']:
    82             OpList.append(G2spc.MT2text(M,T))
    83         self.oprs = wx.RadioBox(panel,-1,'Choose space group operator?',choices=OpList,
    84             majorDimension=Ncol)
    85         self.oprs.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
    86         mainSizer.Add(self.oprs,0,wx.ALIGN_CENTER_VERTICAL)
    87         mainSizer.Add((5,5),0)
    88         mainSizer.Add(wx.StaticText(panel,-1,"   Choose unit cell?"),0,wx.ALIGN_CENTER_VERTICAL)
    89         mainSizer.Add((5,5),0)
    90         cellSizer = wx.BoxSizer(wx.HORIZONTAL)
    91         cellSizer.Add((5,0),0)
    92         cellName = ['X','Y','Z']
    93         self.cell = []
    94         for i in range(3):
    95             self.cell.append(wx.SpinCtrl(panel,-1,cellName[i],size=wx.Size(50,20)))
    96             self.cell[-1].SetRange(-3,3)
    97             self.cell[-1].SetValue(0)
    98             self.cell[-1].Bind(wx.EVT_SPINCTRL, self.OnOpSelect)
    99             cellSizer.Add(self.cell[-1],0,wx.ALIGN_CENTER_VERTICAL)
    100         mainSizer.Add(cellSizer,0,)
    101         if self.New:
    102             choice = ['No','Yes']
    103             self.new = wx.RadioBox(panel,-1,'Generate new positions?',choices=choice)
    104             self.new.Bind(wx.EVT_RADIOBOX, self.OnOpSelect)
    105             mainSizer.Add(self.new,0,wx.ALIGN_CENTER_VERTICAL)
    106         mainSizer.Add((5,5),0)
    107 
    108         OkBtn = wx.Button(panel,-1,"Ok")
    109         OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
    110         cancelBtn = wx.Button(panel,-1,"Cancel")
    111         cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
    112         btnSizer = wx.BoxSizer(wx.HORIZONTAL)
    113         btnSizer.Add((20,20),1)
    114         btnSizer.Add(OkBtn)
    115         btnSizer.Add((20,20),1)
    116         btnSizer.Add(cancelBtn)
    117         btnSizer.Add((20,20),1)
    118 
    119         mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
    120         panel.SetSizer(mainSizer)
    121         panel.Fit()
    122         self.Fit()
    123 
    124     def OnOpSelect(self,event):
    125         if self.SGData['SGInv']:
    126             self.OpSelected[0] = self.inv.GetSelection()
    127         if self.SGData['SGLatt'] != 'P':
    128             self.OpSelected[1] = self.latt.GetSelection()
    129         self.OpSelected[2] = self.oprs.GetSelection()
    130         for i in range(3):
    131             self.OpSelected[3][i] = float(self.cell[i].GetValue())
    132         if self.New:
    133             self.OpSelected[4] = self.new.GetSelection()
    134         if self.Force:
    135             self.OpSelected[5] = self.force.GetSelection()
    136 
    137     def GetSelection(self):
    138         return self.OpSelected
    139 
    140     def OnOk(self,event):
    141         parent = self.GetParent()
    142         parent.Raise()
    143         self.EndModal(wx.ID_OK)
    144 
    145     def OnCancel(self,event):
    146         parent = self.GetParent()
    147         parent.Raise()
    148         self.EndModal(wx.ID_CANCEL)
    149 
    150 class DisAglDialog(wx.Dialog):
     49def UpdatePhaseData(G2frame,Item,data,oldPage):
    15150   
    152     def __default__(self,data,default):
    153         if data:
    154             self.data = data
    155         else:
    156             self.data = {}
    157             self.data['Name'] = default['Name']
    158             self.data['Factors'] = [0.85,0.85]
    159             self.data['AtomTypes'] = default['AtomTypes']
    160             self.data['BondRadii'] = default['BondRadii']
    161             self.data['AngleRadii'] = default['AngleRadii']
    162        
    163     def __init__(self,parent,data,default):
    164         wx.Dialog.__init__(self,parent,-1,'Distance Angle Controls',
    165             pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
    166         self.default = default
    167         self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
    168         self.__default__(data,self.default)
    169         self.Draw(self.data)
    170                
    171     def Draw(self,data):
    172         self.panel.Destroy()
    173         self.panel = wx.Panel(self)
    174         mainSizer = wx.BoxSizer(wx.VERTICAL)
    175         mainSizer.Add(wx.StaticText(self.panel,-1,'Controls for phase '+data['Name']),
    176             0,wx.ALIGN_CENTER_VERTICAL|wx.LEFT,10)
    177         mainSizer.Add((10,10),1)
    178        
    179         radiiSizer = wx.FlexGridSizer(2,3,5,5)
    180         radiiSizer.Add(wx.StaticText(self.panel,-1,' Type'),0,wx.ALIGN_CENTER_VERTICAL)
    181         radiiSizer.Add(wx.StaticText(self.panel,-1,'Bond radii'),0,wx.ALIGN_CENTER_VERTICAL)
    182         radiiSizer.Add(wx.StaticText(self.panel,-1,'Angle radii'),0,wx.ALIGN_CENTER_VERTICAL)
    183         self.objList = {}
    184         for id,item in enumerate(self.data['AtomTypes']):
    185             radiiSizer.Add(wx.StaticText(self.panel,-1,' '+item),0,wx.ALIGN_CENTER_VERTICAL)
    186             bRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['BondRadii'][id]),style=wx.TE_PROCESS_ENTER)
    187             self.objList[bRadii.GetId()] = ['BondRadii',id]
    188             bRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
    189             bRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
    190             radiiSizer.Add(bRadii,0,wx.ALIGN_CENTER_VERTICAL)
    191             aRadii = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['AngleRadii'][id]),style=wx.TE_PROCESS_ENTER)
    192             self.objList[aRadii.GetId()] = ['AngleRadii',id]
    193             aRadii.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
    194             aRadii.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
    195             radiiSizer.Add(aRadii,0,wx.ALIGN_CENTER_VERTICAL)
    196         mainSizer.Add(radiiSizer,0,wx.EXPAND)
    197         factorSizer = wx.FlexGridSizer(2,2,5,5)
    198         Names = ['Bond','Angle']
    199         for i,name in enumerate(Names):
    200             factorSizer.Add(wx.StaticText(self.panel,-1,name+' search factor'),0,wx.ALIGN_CENTER_VERTICAL)
    201             bondFact = wx.TextCtrl(self.panel,-1,value='%.3f'%(data['Factors'][i]),style=wx.TE_PROCESS_ENTER)
    202             self.objList[bondFact.GetId()] = ['Factors',i]
    203             bondFact.Bind(wx.EVT_TEXT_ENTER,self.OnRadiiVal)
    204             bondFact.Bind(wx.EVT_KILL_FOCUS,self.OnRadiiVal)
    205             factorSizer.Add(bondFact)
    206         mainSizer.Add(factorSizer,0,wx.EXPAND)
    207        
    208         OkBtn = wx.Button(self.panel,-1,"Ok")
    209         OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
    210         ResetBtn = wx.Button(self.panel,-1,'Reset')
    211         ResetBtn.Bind(wx.EVT_BUTTON, self.OnReset)
    212         btnSizer = wx.BoxSizer(wx.HORIZONTAL)
    213         btnSizer.Add((20,20),1)
    214         btnSizer.Add(OkBtn)
    215         btnSizer.Add(ResetBtn)
    216         btnSizer.Add((20,20),1)
    217         mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
    218         self.panel.SetSizer(mainSizer)
    219         self.panel.Fit()
    220         self.Fit()
     51#patch
     52    if 'RBModels' not in data:
     53        data['RBModels'] = {}
     54#end patch   
    22155   
    222     def OnRadiiVal(self,event):
    223         Obj = event.GetEventObject()
    224         item = self.objList[Obj.GetId()]
    225         try:
    226             self.data[item[0]][item[1]] = float(Obj.GetValue())
    227         except ValueError:
    228             pass
    229         Obj.SetValue("%.3f"%(self.data[item[0]][item[1]]))          #reset in case of error
    230        
    231     def GetData(self):
    232         return self.data
    233        
    234     def OnOk(self,event):
    235         parent = self.GetParent()
    236         parent.Raise()
    237         self.EndModal(wx.ID_OK)             
    238        
    239     def OnReset(self,event):
    240         data = {}
    241         self.__default__(data,self.default)
    242         self.Draw(self.data)
    243        
    244 class SingleFloatDialog(wx.Dialog):
    245    
    246     def __init__(self,parent,title,prompt,value,limits=[0.,1.],format='%.5g'):
    247         wx.Dialog.__init__(self,parent,-1,title,
    248             pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
    249         self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
    250         self.limits = limits
    251         self.value = value
    252         self.prompt = prompt
    253         self.format = format
    254         self.Draw()
    255        
    256     def Draw(self):
    257        
    258         def OnValItem(event):
    259             try:
    260                 val = float(valItem.GetValue())
    261                 if val < self.limits[0] or val > self.limits[1]:
    262                     raise ValueError
    263             except ValueError:
    264                 val = self.value
    265             self.value = val
    266             valItem.SetValue(self.format%(self.value))
    267            
    268         self.panel.Destroy()
    269         self.panel = wx.Panel(self)
    270         mainSizer = wx.BoxSizer(wx.VERTICAL)
    271         mainSizer.Add(wx.StaticText(self.panel,-1,self.prompt),0,wx.ALIGN_CENTER)
    272         valItem = wx.TextCtrl(self.panel,-1,value=self.format%(self.value),style=wx.TE_PROCESS_ENTER)
    273         mainSizer.Add(valItem,0,wx.ALIGN_CENTER)
    274         valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
    275         valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
    276         OkBtn = wx.Button(self.panel,-1,"Ok")
    277         OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
    278         CancelBtn = wx.Button(self.panel,-1,'Cancel')
    279         CancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
    280         btnSizer = wx.BoxSizer(wx.HORIZONTAL)
    281         btnSizer.Add((20,20),1)
    282         btnSizer.Add(OkBtn)
    283         btnSizer.Add(CancelBtn)
    284         btnSizer.Add((20,20),1)
    285         mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
    286         self.panel.SetSizer(mainSizer)
    287         self.panel.Fit()
    288         self.Fit()
    289 
    290     def GetValue(self):
    291         return self.value
    292        
    293     def OnOk(self,event):
    294         parent = self.GetParent()
    295         parent.Raise()
    296         self.EndModal(wx.ID_OK)             
    297        
    298     def OnCancel(self,event):
    299         parent = self.GetParent()
    300         parent.Raise()
    301         self.EndModal(wx.ID_CANCEL)
    302        
    303 class GridFractionEditor(wg.PyGridCellEditor):
    304     def __init__(self,grid):
    305         wg.PyGridCellEditor.__init__(self)
    306 
    307     def Create(self, parent, id, evtHandler):
    308         self._tc = wx.TextCtrl(parent, id, "")
    309         self._tc.SetInsertionPoint(0)
    310         self.SetControl(self._tc)
    311 
    312         if evtHandler:
    313             self._tc.PushEventHandler(evtHandler)
    314 
    315         self._tc.Bind(wx.EVT_CHAR, self.OnChar)
    316 
    317     def SetSize(self, rect):
    318         self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
    319                                wx.SIZE_ALLOW_MINUS_ONE)
    320 
    321     def BeginEdit(self, row, col, grid):
    322         self.startValue = grid.GetTable().GetValue(row, col)
    323         self._tc.SetValue(str(self.startValue))
    324         self._tc.SetInsertionPointEnd()
    325         self._tc.SetFocus()
    326         self._tc.SetSelection(0, self._tc.GetLastPosition())
    327 
    328     def EndEdit(self, row, col, grid):
    329         changed = False
    330 
    331         val = self._tc.GetValue().lower()
    332        
    333         if val != self.startValue:
    334             changed = True
    335             neg = False
    336             if '-' in val:
    337                 neg = True
    338             if '/' in val and '.' not in val:
    339                 val += '.'
    340             elif 's' in val and not 'sind(' in val:
    341                 if neg:
    342                     val = '-sind('+val.strip('-s')+')'
    343                 else:
    344                     val = 'sind('+val.strip('s')+')'
    345             elif 'c' in val and not 'cosd(' in val:
    346                 if neg:
    347                     val = '-cosd('+val.strip('-c')+')'
    348                 else:
    349                     val = 'cosd('+val.strip('c')+')'
    350             try:
    351                 val = float(eval(val))
    352             except (SyntaxError,NameError):
    353                 val = self.startValue
    354             grid.GetTable().SetValue(row, col, val) # update the table
    355 
    356         self.startValue = ''
    357         self._tc.SetValue('')
    358         return changed
    359 
    360     def Reset(self):
    361         self._tc.SetValue(self.startValue)
    362         self._tc.SetInsertionPointEnd()
    363 
    364     def Clone(self):
    365         return GridFractionEditor(grid)
    366 
    367     def StartingKey(self, evt):
    368         self.OnChar(evt)
    369         if evt.GetSkipped():
    370             self._tc.EmulateKeyPress(evt)
    371 
    372     def OnChar(self, evt):
    373         key = evt.GetKeyCode()
    374         if key == 15:
    375             return
    376         if key > 255:
    377             evt.Skip()
    378             return
    379         char = chr(key)
    380         if char in '.+-/0123456789cosind()':
    381             self._tc.WriteText(char)
    382         else:
    383             evt.Skip()
    384 
    385 def UpdatePhaseData(G2frame,Item,data,oldPage):
    386 
    387     Atoms = []
     56#    Atoms = []         #not needed??
    38857    if G2frame.dataDisplay:
    38958        G2frame.dataDisplay.Destroy()
     
    42089            generalData['MCSA controls'] = {'Data source':'','Annealing':[50.0,0.001,0.90,1000],
    42190            'dmin':2.0,'Algolrithm':'Normal','Jump coeff':[0.95,0.5]} #'Normal','Random jump','Tremayne jump'
     91# end of patches
    42292        generalData['NoAtoms'] = {}
    42393        generalData['BondRadii'] = []
     
    538208            nameSizer.Add(NameTxt,0,wx.ALIGN_CENTER_VERTICAL)
    539209            nameSizer.Add(wx.StaticText(dataDisplay,-1,'  Phase type: '),0,wx.ALIGN_CENTER_VERTICAL)
    540             if len(data['Atoms']):
    541                 choices = phaseTypes[:-1]
    542             else:
    543                 choices = phaseTypes           
    544             TypeTxt = wx.ComboBox(dataDisplay,-1,value=generalData['Type'],choices=choices,
     210            TypeTxt = wx.ComboBox(dataDisplay,-1,value=generalData['Type'],choices=phaseTypes,
    545211                style=wx.CB_READONLY|wx.CB_DROPDOWN)
    546212            TypeTxt.Bind(wx.EVT_COMBOBOX, OnPhaseType)
     
    1076742################################################################################
    1077743
    1078     def FillAtomsGrid():
     744    def FillAtomsGrid(Atoms):
    1079745
    1080746        G2frame.dataFrame.setSizePosLeft([700,300])
     
    13991065            attr = wx.grid.GridCellAttr()
    14001066            attr.IncRef()               #fix from Jim Hester
    1401             attr.SetEditor(GridFractionEditor(Atoms))
     1067            attr.SetEditor(G2gd.GridFractionEditor(Atoms))
    14021068            for c in range(colX,colX+3):
    14031069                Atoms.SetColAttr(c, attr)
     
    14411107    def OnAtomAdd(event):
    14421108        AtomAdd(0,0,0)
    1443         FillAtomsGrid()
     1109        FillAtomsGrid(Atoms)
    14441110        event.StopPropagation()
    14451111       
     
    14511117        except:
    14521118            AtomAdd(0,0,0)
    1453         FillAtomsGrid()
     1119        FillAtomsGrid(Atoms)
    14541120        event.StopPropagation()
    14551121               
     
    14741140    def OnAtomInsert(event):
    14751141        AtomInsert(0,0,0)
    1476         FillAtomsGrid()
     1142        FillAtomsGrid(Atoms)
    14771143        event.StopPropagation()
    14781144       
     
    14821148            x,y,z = drawData['viewPoint'][0]
    14831149            AtomAdd(x,y,z)
    1484             FillAtomsGrid()
     1150            FillAtomsGrid(Atoms)
    14851151        event.StopPropagation()
     1152       
     1153    def OnRBAppend(event):
     1154
     1155        print 'RB append'
     1156       
     1157    def OnRBAssign(event):
     1158        print 'RB assign'
    14861159
    14871160    def OnAtomMove(event):
     
    14971170            atomData[indx[0]][cx:cx+3] = [x,y,z]
    14981171            SetupGeneral()
    1499             FillAtomsGrid()
     1172            FillAtomsGrid(Atoms)
    15001173            ID = atomData[indx[0]][-1]
    15011174            DrawAtomsReplaceByID(data['Drawing'],atomData[indx[0]],ID)
     
    15031176        event.StopPropagation()
    15041177           
     1178    def DrawAtomsReplaceByID(drawingData,atom,ID):
     1179        IDs = [ID,]
     1180        atomData = drawingData['Atoms']
     1181        indx = G2mth.FindAtomIndexByIDs(atomData,IDs)
     1182        for ind in indx:
     1183            atomData[ind] = MakeDrawAtom(atom,atomData[ind])
     1184               
     1185    def MakeDrawAtom(atom,oldatom=None):
     1186        AA3letter = ['ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY','HIS','ILE',
     1187            'LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL','MSE','HOH','WAT','UNK']
     1188        AA1letter = ['A','R','N','D','C','Q','E','G','H','I',
     1189            'L','K','M','F','P','S','T','W','Y','V','M',' ',' ',' ']
     1190        generalData = data['General']
     1191        SGData = generalData['SGData']
     1192        if generalData['Type'] == 'nuclear':
     1193            if oldatom:
     1194                opr = oldatom[5]
     1195                if atom[9] == 'A':                   
     1196                    X,U = G2spc.ApplyStringOps(opr,SGData,atom[3:6],atom[11:17])
     1197                    atomInfo = [atom[:2]+list(X)+oldatom[5:9]+atom[9:11]+list(U)+oldatom[17:]][0]
     1198                else:
     1199                    X = G2spc.ApplyStringOps(opr,SGData,atom[3:6])
     1200                    atomInfo = [atom[:2]+list(X)+oldatom[5:9]+atom[9:]+oldatom[17:]][0]
     1201            else:
     1202                atomInfo = [atom[:2]+atom[3:6]+['1',]+['vdW balls',]+
     1203                    ['',]+[[255,255,255],]+atom[9:]+[[],[]]][0]
     1204            ct,cs = [1,8]         #type & color
     1205        elif generalData['Type'] == 'macromolecular':
     1206            try:
     1207                oneLetter = AA3letter.index(atom[1])
     1208            except ValueError:
     1209                oneLetter = -1
     1210            atomInfo = [[atom[1].strip()+atom[0],]+
     1211                [AA1letter[oneLetter]+atom[0],]+atom[2:5]+
     1212                atom[6:9]+['1',]+['sticks',]+['',]+[[255,255,255],]+atom[12:]+[[],[]]][0]
     1213            ct,cs = [4,11]         #type & color
     1214        elif generalData['Type'] == 'magnetic':
     1215            if oldatom:
     1216                atomInfo = [atom[:2]+oldatom[3:]][0]
     1217            else:
     1218                atomInfo = [atom[:2]+atom[3:6]+['vdW balls',]+['',]+atom[9:]+[[],[]]][0]
     1219            ct,cs = [1,8]         #type & color
     1220    #     elif generalData['Type'] == 'modulated':
     1221    #        ?????   for future
     1222        atNum = generalData['AtomTypes'].index(atom[ct])
     1223        atomInfo[cs] = list(generalData['Color'][atNum])
     1224        return atomInfo
     1225       
    15051226    def AtomInsert(x,y,z):
    15061227        indx = Atoms.GetSelectedRows()
     
    15331254            if 'Atoms' in data['Drawing']:
    15341255                DrawAtomsDeleteByIDs(IDs)
    1535                 wx.CallAfter(FillAtomsGrid)
     1256                wx.CallAfter(FillAtomsGrid,Atoms)
    15361257                G2plt.PlotStructure(G2frame,data)
    15371258            SetupGeneral()
     
    15911312                                ID = atomData[r][-1]
    15921313                                DrawAtomsReplaceByID(data['Drawing'],atomData[r],ID)
    1593                     FillAtomsGrid()
     1314                    FillAtomsGrid(Atoms)
    15941315                dlg.Destroy()
    15951316            elif parm in ['Name',]:
     
    16051326                            else:
    16061327                                atomData[r][cid] = El[:1]+'(%d)'%(r+1)
    1607                     FillAtomsGrid()
     1328                    FillAtomsGrid(Atoms)
    16081329                finally:
    16091330                    dlg.Destroy()
     
    16171338                    for r in indx:                       
    16181339                        atomData[r][cid] = parm
    1619                     FillAtomsGrid()
     1340                    FillAtomsGrid(Atoms)
    16201341                dlg.Destroy()
    16211342            elif parm in ['frac','Uiso']:
     
    16251346                    limits = [0.,0.25]
    16261347                    val = 0.01
    1627                 dlg = SingleFloatDialog(G2frame,'New value','Enter new value for '+parm,val,limits)
     1348                dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for '+parm,val,limits)
    16281349                if dlg.ShowModal() == wx.ID_OK:
    16291350                    parm = dlg.GetValue()
     
    16311352                        atomData[r][cid] = parm
    16321353                    SetupGeneral()
    1633                     FillAtomsGrid()
     1354                    FillAtomsGrid(Atoms)
    16341355                dlg.Destroy()
    16351356            elif parm in ['x','y','z']:
    16361357                limits = [-1.,1.]
    16371358                val = 0.
    1638                 dlg = SingleFloatDialog(G2frame,'Atom shift','Enter shift for '+parm,val,limits)
     1359                dlg = G2gd.SingleFloatDialog(G2frame,'Atom shift','Enter shift for '+parm,val,limits)
    16391360                if dlg.ShowModal() == wx.ID_OK:
    16401361                    parm = dlg.GetValue()
     
    16421363                        atomData[r][cid] += parm
    16431364                    SetupGeneral()
    1644                     FillAtomsGrid()
     1365                    FillAtomsGrid(Atoms)
    16451366                dlg.Destroy()
    16461367
     
    16571378            generalData = data['General']
    16581379            SGData = generalData['SGData']
    1659             dlg = SymOpDialog(G2frame,SGData,True,True)
     1380            dlg = G2gd.SymOpDialog(G2frame,SGData,True,True)
    16601381            New = False
    16611382            try:
     
    16911412            Atoms.ClearSelection()
    16921413            if New:
    1693                 FillAtomsGrid()
     1414                FillAtomsGrid(Atoms)
    16941415            else:
    16951416                Atoms.ForceRefresh()
     
    17061427            if 'DisAglCtls' in generalData:
    17071428                DisAglCtls = generalData['DisAglCtls']
    1708             dlg = DisAglDialog(G2frame,DisAglCtls,generalData)
     1429            dlg = G2gd.DisAglDialog(G2frame,DisAglCtls,generalData)
    17091430            if dlg.ShowModal() == wx.ID_OK:
    17101431                DisAglCtls = dlg.GetData()
     
    17851506            data['Drawing'] = drawingData
    17861507           
    1787     def MakeDrawAtom(atom,oldatom=None):
    1788         AA3letter = ['ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY','HIS','ILE',
    1789             'LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL','MSE','HOH','WAT','UNK']
    1790         AA1letter = ['A','R','N','D','C','Q','E','G','H','I',
    1791             'L','K','M','F','P','S','T','W','Y','V','M',' ',' ',' ']
    1792         generalData = data['General']
    1793         SGData = generalData['SGData']
    1794         if generalData['Type'] == 'nuclear':
    1795             if oldatom:
    1796                 opr = oldatom[5]
    1797                 if atom[9] == 'A':                   
    1798                     X,U = G2spc.ApplyStringOps(opr,SGData,atom[3:6],atom[11:17])
    1799                     atomInfo = [atom[:2]+list(X)+oldatom[5:9]+atom[9:11]+list(U)+oldatom[17:]][0]
    1800                 else:
    1801                     X = G2spc.ApplyStringOps(opr,SGData,atom[3:6])
    1802                     atomInfo = [atom[:2]+list(X)+oldatom[5:9]+atom[9:]+oldatom[17:]][0]
    1803             else:
    1804                 atomInfo = [atom[:2]+atom[3:6]+['1',]+['vdW balls',]+
    1805                     ['',]+[[255,255,255],]+atom[9:]+[[],[]]][0]
    1806             ct,cs = [1,8]         #type & color
    1807         elif generalData['Type'] == 'macromolecular':
    1808             try:
    1809                 oneLetter = AA3letter.index(atom[1])
    1810             except ValueError:
    1811                 oneLetter = -1
    1812             atomInfo = [[atom[1].strip()+atom[0],]+
    1813                 [AA1letter[oneLetter]+atom[0],]+atom[2:5]+
    1814                 atom[6:9]+['1',]+['sticks',]+['',]+[[255,255,255],]+atom[12:]+[[],[]]][0]
    1815             ct,cs = [4,11]         #type & color
    1816         elif generalData['Type'] == 'magnetic':
    1817             if oldatom:
    1818                 atomInfo = [atom[:2]+oldatom[3:]][0]
    1819             else:
    1820                 atomInfo = [atom[:2]+atom[3:6]+['vdW balls',]+['',]+atom[9:]+[[],[]]][0]
    1821             ct,cs = [1,8]         #type & color
    1822 #        elif generalData['Type'] == 'modulated':
    1823 #           ?????   for future
    1824         atNum = generalData['AtomTypes'].index(atom[ct])
    1825         atomInfo[cs] = list(generalData['Color'][atNum])
    1826         return atomInfo
    1827            
    18281508    def DrawAtomAdd(drawingData,atom):
    18291509        drawingData['Atoms'].append(MakeDrawAtom(atom))
    18301510       
    1831     def DrawAtomsReplaceByID(drawingData,atom,ID):
    1832         IDs = [ID,]
    1833         atomData = drawingData['Atoms']
    1834         indx = G2mth.FindAtomIndexByIDs(atomData,IDs)
    1835         for ind in indx:
    1836             atomData[ind] = MakeDrawAtom(atom,atomData[ind])
    1837            
    18381511    def OnRestraint(event):       
    18391512        indx = drawAtoms.GetSelectedRows()
     
    22421915            generalData = data['General']
    22431916            SGData = generalData['SGData']
    2244             dlg = SymOpDialog(G2frame,SGData,False,True)
     1917            dlg = G2gd.SymOpDialog(G2frame,SGData,False,True)
    22451918            try:
    22461919                if dlg.ShowModal() == wx.ID_OK:
     
    22891962            generalData = data['General']
    22901963            SGData = generalData['SGData']
    2291             dlg = SymOpDialog(G2frame,SGData,False,True)
     1964            dlg = G2gd.SymOpDialog(G2frame,SGData,False,True)
    22921965            try:
    22931966                if dlg.ShowModal() == wx.ID_OK:
     
    31882861
    31892862################################################################################
    3190 ##### DData routines
     2863##### DData routines - GUI stuff in GSASIIddataGUI.py
    31912864################################################################################
    3192        
    3193     def UpdateDData():
    3194         G2frame.dataFrame.SetStatusText('')
    3195         UseList = data['Histograms']
    3196         if UseList:
    3197             G2frame.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,True)
    3198             for item in G2frame.Refine: item.Enable(True)
    3199         else:
    3200             G2frame.dataFrame.DataMenu.Enable(G2gd.wxID_DATADELETE,False)
    3201             for item in G2frame.Refine: item.Enable(False)
    3202         generalData = data['General']       
    3203         SGData = generalData['SGData']
    3204         keyList = UseList.keys()
    3205         keyList.sort()
    3206         PWDR = any(['PWDR' in item for item in keyList])
    3207         Indx = {}
    3208        
    3209         def PlotSizer():
    3210 
    3211             def OnPlotSel(event):
    3212                 Obj = event.GetEventObject()
    3213                 generalData['Data plot type'] = Obj.GetStringSelection()
    3214                 wx.CallAfter(UpdateDData)
    3215                 G2plt.PlotSizeStrainPO(G2frame,data)
    3216                
    3217             def OnPOhkl(event):
    3218                 Obj = event.GetEventObject()
    3219                 Saxis = Obj.GetValue().split()
    3220                 try:
    3221                     hkl = [int(Saxis[i]) for i in range(3)]
    3222                 except (ValueError,IndexError):
    3223                     hkl = generalData['POhkl']
    3224                 if not np.any(np.array(hkl)):
    3225                     hkl = generalData['POhkl']
    3226                 generalData['POhkl'] = hkl
    3227                 h,k,l = hkl
    3228                 Obj.SetValue('%3d %3d %3d'%(h,k,l))
    3229                 G2plt.PlotSizeStrainPO(G2frame,data)
    3230            
    3231             plotSizer = wx.BoxSizer(wx.VERTICAL)
    3232             choice = ['None','Mustrain','Size','Preferred orientation']
    3233             plotSel = wx.RadioBox(DData,-1,'Select plot type:',choices=choice,
    3234                 majorDimension=2,style=wx.RA_SPECIFY_COLS)
    3235             plotSel.SetStringSelection(generalData['Data plot type'])
    3236             plotSel.Bind(wx.EVT_RADIOBOX,OnPlotSel)   
    3237             plotSizer.Add(plotSel)
    3238             if generalData['Data plot type'] == 'Preferred orientation':
    3239                 POhklSizer = wx.BoxSizer(wx.HORIZONTAL)
    3240                 POhklSizer.Add(wx.StaticText(DData,-1,' Plot preferred orientation for H K L: '),0,wx.ALIGN_CENTER_VERTICAL)
    3241                 h,k,l = generalData['POhkl']
    3242                 poAxis = wx.TextCtrl(DData,-1,'%3d %3d %3d'%(h,k,l),style=wx.TE_PROCESS_ENTER)
    3243                 poAxis.Bind(wx.EVT_TEXT_ENTER,OnPOhkl)
    3244                 poAxis.Bind(wx.EVT_KILL_FOCUS,OnPOhkl)
    3245                 POhklSizer.Add(poAxis,0,wx.ALIGN_CENTER_VERTICAL)
    3246                 plotSizer.Add(POhklSizer)           
    3247             return plotSizer
    3248            
    3249         def ScaleSizer():
    3250            
    3251             def OnScaleRef(event):
    3252                 Obj = event.GetEventObject()
    3253                 UseList[Indx[Obj.GetId()]]['Scale'][1] = Obj.GetValue()
    3254                
    3255             def OnScaleVal(event):
    3256                 Obj = event.GetEventObject()
    3257                 try:
    3258                     scale = float(Obj.GetValue())
    3259                     if scale > 0:
    3260                         UseList[Indx[Obj.GetId()]]['Scale'][0] = scale
    3261                 except ValueError:
    3262                     pass
    3263                 Obj.SetValue("%.4f"%(UseList[Indx[Obj.GetId()]]['Scale'][0]))          #reset in case of error
    3264                            
    3265             scaleSizer = wx.BoxSizer(wx.HORIZONTAL)
    3266             if 'PWDR' in item:
    3267                 scaleRef = wx.CheckBox(DData,-1,label=' Phase fraction: ')
    3268             elif 'HKLF' in item:
    3269                 scaleRef = wx.CheckBox(DData,-1,label=' Scale factor: ')               
    3270             scaleRef.SetValue(UseList[item]['Scale'][1])
    3271             Indx[scaleRef.GetId()] = item
    3272             scaleRef.Bind(wx.EVT_CHECKBOX, OnScaleRef)
    3273             scaleSizer.Add(scaleRef,0,wx.ALIGN_CENTER_VERTICAL)
    3274             scaleVal = wx.TextCtrl(DData,wx.ID_ANY,
    3275                 '%.4f'%(UseList[item]['Scale'][0]),style=wx.TE_PROCESS_ENTER)
    3276             Indx[scaleVal.GetId()] = item
    3277             scaleVal.Bind(wx.EVT_TEXT_ENTER,OnScaleVal)
    3278             scaleVal.Bind(wx.EVT_KILL_FOCUS,OnScaleVal)
    3279             scaleSizer.Add(scaleVal,0,wx.ALIGN_CENTER_VERTICAL)
    3280             return scaleSizer
    3281            
    3282         def OnUseData(event):
    3283             Obj = event.GetEventObject()
    3284             hist = Indx[Obj.GetId()]
    3285             UseList[hist]['Use'] = Obj.GetValue()
    3286            
    3287         def OnShowData(event):
    3288             Obj = event.GetEventObject()
    3289             hist = Indx[Obj.GetId()]
    3290             UseList[hist]['Show'] = Obj.GetValue()
    3291             wx.CallAfter(UpdateDData)
    3292             G2plt.PlotSizeStrainPO(G2frame,data)
    3293            
    3294         def OnCopyData(event):
    3295             #how about HKLF data? This is only for PWDR data
    3296             Obj = event.GetEventObject()
    3297             hist = Indx[Obj.GetId()]
    3298             sourceDict = UseList[hist]
    3299             copyNames = ['Scale','Pref.Ori.','Size','Mustrain','HStrain','Extinction','Babinet']
    3300             copyDict = {}
    3301             for name in copyNames:
    3302                 copyDict[name] = copy.deepcopy(sourceDict[name])        #force copy
    3303             keyList = ['All',]+UseList.keys()
    3304             if UseList:
    3305                 copyList = []
    3306                 dlg = wx.MultiChoiceDialog(G2frame,
    3307                     'Copy parameters to which histograms?', 'Copy parameters',
    3308                     keyList, wx.CHOICEDLG_STYLE)
    3309                 try:
    3310                     if dlg.ShowModal() == wx.ID_OK:
    3311                         result = dlg.GetSelections()
    3312                         for i in result:
    3313                             copyList.append(keyList[i])
    3314                         if 'All' in copyList:
    3315                             copyList = keyList[1:]
    3316                         for item in copyList:
    3317                             UseList[item].update(copy.deepcopy(copyDict))
    3318                         wx.CallAfter(UpdateDData)
    3319                 finally:
    3320                     dlg.Destroy()
    3321                    
    3322         def OnCopyFlags(event):
    3323             Obj = event.GetEventObject()
    3324             hist = Indx[Obj.GetId()]
    3325             sourceDict = UseList[hist]
    3326             copyDict = {}
    3327             copyNames = ['Scale','Pref.Ori.','Size','Mustrain','HStrain','Extinction','Babinet']
    3328             babNames = ['BabA','BabU']
    3329             for name in copyNames:
    3330                 if name in ['Scale','Extinction','HStrain']:
    3331                     copyDict[name] = sourceDict[name][1]
    3332                 elif name in ['Size','Mustrain']:
    3333                     copyDict[name] = [sourceDict[name][0],sourceDict[name][2],sourceDict[name][4]]
    3334                 elif name == 'Pref.Ori.':
    3335                     copyDict[name] = [sourceDict[name][0],sourceDict[name][2]]
    3336                     if sourceDict[name][0] == 'SH':
    3337                         SHterms = sourceDict[name][5]
    3338                         SHflags = {}
    3339                         for item in SHterms:
    3340                             SHflags[item] = SHterms[item][1]
    3341                         copyDict[name].append(SHflags)
    3342                 elif name == 'Babinet':
    3343                     copyDict[name] = {}
    3344                     for bab in babNames:
    3345                         copyDict[name][bab] = sourceDict[name][bab][1]                       
    3346             keyList = ['All',]+UseList.keys()
    3347             if UseList:
    3348                 copyList = []
    3349                 dlg = wx.MultiChoiceDialog(G2frame,
    3350                     'Copy parameters to which histograms?', 'Copy parameters',
    3351                     keyList, wx.CHOICEDLG_STYLE)
    3352                 try:
    3353                     if dlg.ShowModal() == wx.ID_OK:
    3354                         result = dlg.GetSelections()
    3355                         for i in result:
    3356                             copyList.append(keyList[i])
    3357                         if 'All' in copyList:
    3358                             copyList = keyList[1:]
    3359                         for item in copyList:
    3360                             UseList[item]                           
    3361                             for name in copyNames:
    3362                                 if name in ['Scale','Extinction','HStrain']:
    3363                                     UseList[item][name][1] = copy.copy(copyDict[name])
    3364                                 elif name in ['Size','Mustrain']:
    3365                                     UseList[item][name][0] = copy.copy(copyDict[name][0])
    3366                                     UseList[item][name][2] = copy.copy(copyDict[name][1])
    3367                                     UseList[item][name][4] = copy.copy(copyDict[name][2])
    3368                                 elif name == 'Pref.Ori.':
    3369                                     UseList[item][name][0] = copy.copy(copyDict[name][0])
    3370                                     UseList[item][name][2] = copy.copy(copyDict[name][1])
    3371                                     if sourceDict[name][0] == 'SH':
    3372                                         SHflags = copy.copy(copyDict[name][2])
    3373                                         SHterms = copy.copy(sourceDict[name][5])
    3374                                         for item in SHflags:
    3375                                             SHterms[item][1] = copy.copy(SHflags[item])
    3376                                 elif name == 'Babinet':
    3377                                     for bab in babNames:
    3378                                         UseList[item][name][bab][1] = copy.copy(copyDict[name][bab])                                             
    3379                         wx.CallAfter(UpdateDData)
    3380                 finally:
    3381                     dlg.Destroy()
    3382            
    3383            
    3384         def OnLGmixRef(event):
    3385             Obj = event.GetEventObject()
    3386             hist,name = Indx[Obj.GetId()]
    3387             UseList[hist][name][2][2] = Obj.GetValue()
    3388            
    3389         def OnLGmixVal(event):
    3390             Obj = event.GetEventObject()
    3391             hist,name = Indx[Obj.GetId()]
    3392             try:
    3393                 value = float(Obj.GetValue())
    3394                 if 0.1 <= value <= 1:
    3395                     UseList[hist][name][1][2] = value
    3396                 else:
    3397                     raise ValueError
    3398             except ValueError:
    3399                 pass
    3400             Obj.SetValue("%.4f"%(UseList[hist][name][1][2]))          #reset in case of error
    3401 
    3402         def OnSizeType(event):
    3403             Obj = event.GetEventObject()
    3404             hist = Indx[Obj.GetId()]
    3405             UseList[hist]['Size'][0] = Obj.GetValue()
    3406             G2plt.PlotSizeStrainPO(G2frame,data)
    3407             wx.CallAfter(UpdateDData)
    3408            
    3409         def OnSizeRef(event):
    3410             Obj = event.GetEventObject()
    3411             hist,pid = Indx[Obj.GetId()]
    3412             if UseList[hist]['Size'][0] == 'ellipsoidal':
    3413                 UseList[hist]['Size'][5][pid] = Obj.GetValue()               
    3414             else:
    3415                 UseList[hist]['Size'][2][pid] = Obj.GetValue()
    3416            
    3417         def OnSizeVal(event):
    3418             Obj = event.GetEventObject()
    3419             hist,pid = Indx[Obj.GetId()]
    3420             if UseList[hist]['Size'][0] == 'ellipsoidal':
    3421                 try:
    3422                     size = float(Obj.GetValue())
    3423                     if pid < 3 and size <= 0.001:            #10A lower limit!
    3424                         raise ValueError
    3425                     UseList[hist]['Size'][4][pid] = size                   
    3426                 except ValueError:
    3427                     pass
    3428                 Obj.SetValue("%.3f"%(UseList[hist]['Size'][4][pid]))          #reset in case of error
    3429             else:
    3430                 try:
    3431                     size = float(Obj.GetValue())
    3432                     if size <= 0.001:            #10A lower limit!
    3433                         raise ValueError
    3434                     UseList[hist]['Size'][1][pid] = size
    3435                 except ValueError:
    3436                     pass
    3437                 Obj.SetValue("%.3f"%(UseList[hist]['Size'][1][pid]))          #reset in case of error
    3438             G2plt.PlotSizeStrainPO(G2frame,data)
    3439            
    3440         def OnSizeAxis(event):           
    3441             Obj = event.GetEventObject()
    3442             hist = Indx[Obj.GetId()]
    3443             Saxis = Obj.GetValue().split()
    3444             try:
    3445                 hkl = [int(Saxis[i]) for i in range(3)]
    3446             except (ValueError,IndexError):
    3447                 hkl = UseList[hist]['Size'][3]
    3448             if not np.any(np.array(hkl)):
    3449                 hkl = UseList[hist]['Size'][3]
    3450             UseList[hist]['Size'][3] = hkl
    3451             h,k,l = hkl
    3452             Obj.SetValue('%3d %3d %3d'%(h,k,l))
    3453                        
    3454         def OnResetSize(event):
    3455             Obj = event.GetEventObject()
    3456             Obj.SetValue(False)
    3457             item,name = Indx[Obj.GetId()]
    3458             if name == 'isotropic':
    3459                 UseList[item]['Size'][1][0] = 1.0
    3460             elif name == 'uniaxial':
    3461                 UseList[item]['Size'][1][0] = 1.0
    3462                 UseList[item]['Size'][1][1] = 1.0
    3463             elif name == 'ellipsoidal':
    3464                 for i in range(3):
    3465                     UseList[item]['Size'][4][i] = 1.0
    3466                     UseList[item]['Size'][4][i+3] = 0.0
    3467             G2plt.PlotSizeStrainPO(G2frame,data)
    3468             wx.CallAfter(UpdateDData)
    3469                
    3470         def OnStrainType(event):
    3471             Obj = event.GetEventObject()
    3472             hist = Indx[Obj.GetId()]
    3473             UseList[hist]['Mustrain'][0] = Obj.GetValue()
    3474             wx.CallAfter(UpdateDData)
    3475             G2plt.PlotSizeStrainPO(G2frame,data)
    3476            
    3477         def OnStrainRef(event):
    3478             Obj = event.GetEventObject()
    3479             hist,pid = Indx[Obj.GetId()]
    3480             if UseList[hist]['Mustrain'][0] == 'generalized':
    3481                 UseList[hist]['Mustrain'][5][pid] = Obj.GetValue()
    3482             else:
    3483                 UseList[hist]['Mustrain'][2][pid] = Obj.GetValue()
    3484            
    3485         def OnStrainVal(event):
    3486             Snames = G2spc.MustrainNames(SGData)
    3487             Obj = event.GetEventObject()
    3488             hist,pid = Indx[Obj.GetId()]
    3489             try:
    3490                 strain = float(Obj.GetValue())
    3491                 if UseList[hist]['Mustrain'][0] == 'generalized':
    3492                     if '4' in Snames[pid] and strain < 0:
    3493                         raise ValueError
    3494                     UseList[hist]['Mustrain'][4][pid] = strain
    3495                 else:
    3496                     if strain <= 0:
    3497                         raise ValueError
    3498                     UseList[hist]['Mustrain'][1][pid] = strain
    3499             except ValueError:
    3500                 pass
    3501             if UseList[hist]['Mustrain'][0] == 'generalized':
    3502                 Obj.SetValue("%.3f"%(UseList[hist]['Mustrain'][4][pid]))          #reset in case of error
    3503             else:
    3504                 Obj.SetValue("%.1f"%(UseList[hist]['Mustrain'][1][pid]))          #reset in case of error
    3505             G2plt.PlotSizeStrainPO(G2frame,data)
    3506            
    3507         def OnStrainAxis(event):
    3508             Obj = event.GetEventObject()
    3509             hist = Indx[Obj.GetId()]
    3510             Saxis = Obj.GetValue().split()
    3511             try:
    3512                 hkl = [int(Saxis[i]) for i in range(3)]
    3513             except (ValueError,IndexError):
    3514                 hkl = UseList[hist]['Mustrain'][3]
    3515             if not np.any(np.array(hkl)):
    3516                 hkl = UseList[hist]['Mustrain'][3]
    3517             UseList[hist]['Mustrain'][3] = hkl
    3518             h,k,l = hkl
    3519             Obj.SetValue('%3d %3d %3d'%(h,k,l))
    3520             G2plt.PlotSizeStrainPO(G2frame,data)
    3521            
    3522         def OnResetStrain(event):
    3523             Obj = event.GetEventObject()
    3524             Obj.SetValue(False)
    3525             item,name = Indx[Obj.GetId()]
    3526             if name == 'isotropic':
    3527                 UseList[item]['Mustrain'][1][0] = 1000.0
    3528             elif name == 'uniaxial':
    3529                 UseList[item]['Mustrain'][1][0] = 1000.0
    3530                 UseList[item]['Mustrain'][1][1] = 1000.0
    3531             elif name == 'generalized':
    3532                 nTerm = len(UseList[item]['Mustrain'][4])
    3533                 for i in range(nTerm):
    3534                     UseList[item]['Mustrain'][4][i] = 0.01
    3535             wx.CallAfter(UpdateDData)
    3536             G2plt.PlotSizeStrainPO(G2frame,data)
    3537                
    3538         def OnHstrainRef(event):
    3539             Obj = event.GetEventObject()
    3540             hist,pid = Indx[Obj.GetId()]
    3541             UseList[hist]['HStrain'][1][pid] = Obj.GetValue()
    3542            
    3543         def OnHstrainVal(event):
    3544             Snames = G2spc.HStrainNames(SGData)
    3545             Obj = event.GetEventObject()
    3546             hist,pid = Indx[Obj.GetId()]
    3547             try:
    3548                 strain = float(Obj.GetValue())
    3549                 UseList[hist]['HStrain'][0][pid] = strain
    3550             except ValueError:
    3551                 pass
    3552             Obj.SetValue("%.5f"%(UseList[hist]['HStrain'][0][pid]))          #reset in case of error
    3553 
    3554         def OnPOVal(event):
    3555             Obj = event.GetEventObject()
    3556             hist = Indx[Obj.GetId()]
    3557             try:
    3558                 mdVal = float(Obj.GetValue())
    3559                 if mdVal > 0:
    3560                     UseList[hist]['Pref.Ori.'][1] = mdVal
    3561             except ValueError:
    3562                 pass
    3563             Obj.SetValue("%.3f"%(UseList[hist]['Pref.Ori.'][1]))          #reset in case of error
    3564            
    3565         def OnPOAxis(event):
    3566             Obj = event.GetEventObject()
    3567             hist = Indx[Obj.GetId()]
    3568             Saxis = Obj.GetValue().split()
    3569             try:
    3570                 hkl = [int(Saxis[i]) for i in range(3)]
    3571             except (ValueError,IndexError):
    3572                 hkl = UseList[hist]['Pref.Ori.'][3]
    3573             if not np.any(np.array(hkl)):
    3574                 hkl = UseList[hist]['Pref.Ori.'][3]
    3575             UseList[hist]['Pref.Ori.'][3] = hkl
    3576             h,k,l = hkl
    3577             Obj.SetValue('%3d %3d %3d'%(h,k,l))
    3578            
    3579         def OnPOOrder(event):
    3580             Obj = event.GetEventObject()
    3581             hist = Indx[Obj.GetId()]
    3582             Order = int(Obj.GetValue())
    3583             UseList[hist]['Pref.Ori.'][4] = Order
    3584             UseList[hist]['Pref.Ori.'][5] = SetPOCoef(Order,hist)
    3585             wx.CallAfter(UpdateDData)
    3586 
    3587         def OnPOType(event):
    3588             Obj = event.GetEventObject()
    3589             hist = Indx[Obj.GetId()]
    3590             if 'March' in Obj.GetValue():
    3591                 UseList[hist]['Pref.Ori.'][0] = 'MD'
    3592             else:
    3593                 UseList[hist]['Pref.Ori.'][0] = 'SH'
    3594             wx.CallAfter(UpdateDData)           
    3595    
    3596         def OnPORef(event):
    3597             Obj = event.GetEventObject()
    3598             hist = Indx[Obj.GetId()]
    3599             UseList[hist]['Pref.Ori.'][2] = Obj.GetValue()
    3600                
    3601         def SetPOCoef(Order,hist):
    3602             cofNames = G2lat.GenSHCoeff(SGData['SGLaue'],'0',Order,False)     #cylindrical & no M
    3603             newPOCoef = dict(zip(cofNames,np.zeros(len(cofNames))))
    3604             POCoeff = UseList[hist]['Pref.Ori.'][5]
    3605             for cofName in POCoeff:
    3606                 if cofName in  cofNames:
    3607                     newPOCoef[cofName] = POCoeff[cofName]
    3608             return newPOCoef
    3609        
    3610         def OnExtRef(event):
    3611             Obj = event.GetEventObject()
    3612             UseList[Indx[Obj.GetId()]]['Extinction'][1] = Obj.GetValue()
    3613            
    3614         def OnExtVal(event):
    3615             Obj = event.GetEventObject()
    3616             try:
    3617                 ext = float(Obj.GetValue())
    3618                 if ext >= 0:
    3619                     UseList[Indx[Obj.GetId()]]['Extinction'][0] = ext
    3620             except ValueError:
    3621                 pass
    3622             Obj.SetValue("%.2f"%(UseList[Indx[Obj.GetId()]]['Extinction'][0]))
    3623 
    3624         def OnBabRef(event):
    3625             Obj = event.GetEventObject()
    3626             item,bab = Indx[Obj.GetId()]
    3627             UseList[item]['Babinet']['Bab'+bab][1] = Obj.GetValue()
    3628            
    3629         def OnBabVal(event):
    3630             Obj = event.GetEventObject()
    3631             item,bab = Indx[Obj.GetId()]
    3632             try:
    3633                 val = float(Obj.GetValue())
    3634                 if val >= 0:
    3635                     UseList[item]['Babinet']['Bab'+bab][0] = val
    3636             except ValueError:
    3637                 pass
    3638             Obj.SetValue("%.3f"%(UseList[item]['Babinet']['Bab'+bab][0]))
    3639 
    3640         def OnTbarVal(event):
    3641             Obj = event.GetEventObject()
    3642             try:
    3643                 tbar = float(Obj.GetValue())
    3644                 if tbar > 0:
    3645                     UseList[Indx[Obj.GetId()]]['Extinction'][2]['Tbar'] = tbar
    3646             except ValueError:
    3647                 pass
    3648             Obj.SetValue("%.3f"%(UseList[Indx[Obj.GetId()]]['Extinction'][2]['Tbar']))
    3649 
    3650         def OnCos2TM(event):
    3651             Obj = event.GetEventObject()
    3652             try:
    3653                 val = float(Obj.GetValue())
    3654                 if 0. < val <= 1.:
    3655                     UseList[Indx[Obj.GetId()]]['Extinction'][2]['Cos2TM'] = val
    3656             except ValueError:
    3657                 pass
    3658             Obj.SetValue("%.3f"%(UseList[Indx[Obj.GetId()]]['Extinction'][2]['Cos2TM']))
    3659            
    3660         def OnEval(event):
    3661             Obj = event.GetEventObject()
    3662             item = Indx[Obj.GetId()]
    3663             try:
    3664                 val = float(Obj.GetValue())
    3665                 if val > 0:
    3666                     UseList[item[0]]['Extinction'][2][item[1]][0] = val
    3667             except ValueError:
    3668                 pass
    3669             Obj.SetValue("%10.3e"%(UseList[item[0]]['Extinction'][2][item[1]][0]))
    3670            
    3671         def OnEref(event):
    3672             Obj = event.GetEventObject()
    3673             item = Indx[Obj.GetId()]
    3674             UseList[item[0]]['Extinction'][2][item[1]][1] = Obj.GetValue()
    3675 
    3676         def OnSCExtType(event):
    3677             Obj = event.GetEventObject()
    3678             item = Indx[Obj.GetId()]
    3679             UseList[item[0]]['Extinction'][item[1]] = Obj.GetValue()
    3680             wx.CallAfter(UpdateDData)
    3681                
    3682         def checkAxis(axis):
    3683             if not np.any(np.array(axis)):
    3684                 return False
    3685             return axis
    3686            
    3687         def TopSizer(name,choices,parm,OnType):
    3688             topSizer = wx.BoxSizer(wx.HORIZONTAL)
    3689             topSizer.Add(wx.StaticText(DData,-1,name),0,wx.ALIGN_CENTER_VERTICAL)
    3690             sizeType = wx.ComboBox(DData,wx.ID_ANY,value=UseList[item][parm][0],choices=choices,
    3691                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
    3692             sizeType.Bind(wx.EVT_COMBOBOX, OnType)
    3693             Indx[sizeType.GetId()] = item
    3694             topSizer.Add(sizeType)
    3695             topSizer.Add((5,0),0)
    3696             return topSizer
    3697            
    3698         def LGmixSizer(name,OnVal,OnRef):
    3699             lgmixSizer = wx.BoxSizer(wx.HORIZONTAL)
    3700             lgmixRef = wx.CheckBox(DData,-1,label='LGmix')
    3701             lgmixRef.thisown = False
    3702             lgmixRef.SetValue(UseList[item][name][2][2])
    3703             Indx[lgmixRef.GetId()] = [item,name]
    3704             lgmixRef.Bind(wx.EVT_CHECKBOX, OnRef)
    3705             lgmixSizer.Add(lgmixRef,0,wx.ALIGN_CENTER_VERTICAL)
    3706             lgmixVal = wx.TextCtrl(DData,wx.ID_ANY,
    3707                 '%.4f'%(UseList[item][name][1][2]),style=wx.TE_PROCESS_ENTER)
    3708             Indx[lgmixVal.GetId()] = [item,name]
    3709             lgmixVal.Bind(wx.EVT_TEXT_ENTER,OnVal)
    3710             lgmixVal.Bind(wx.EVT_KILL_FOCUS,OnVal)
    3711             lgmixSizer.Add(lgmixVal,0,wx.ALIGN_CENTER_VERTICAL)
    3712             return lgmixSizer
    3713                        
    3714         def ResetSizer(name,OnReset):
    3715             resetSizer = wx.BoxSizer(wx.HORIZONTAL)
    3716             resetSizer.Add((5,0),0)
    3717             reset = wx.CheckBox(DData,-1,label='Reset?')
    3718             reset.thisown = False
    3719             reset.SetValue(False)
    3720             Indx[reset.GetId()] = [item,name]
    3721             reset.Bind(wx.EVT_CHECKBOX,OnReset)
    3722             resetSizer.Add(reset,0,wx.ALIGN_CENTER_VERTICAL)
    3723             return resetSizer
    3724            
    3725         def IsoSizer(name,parm,fmt,OnVal,OnRef):
    3726             isoSizer = wx.BoxSizer(wx.HORIZONTAL)
    3727             sizeRef = wx.CheckBox(DData,-1,label=name)
    3728             sizeRef.thisown = False
    3729             sizeRef.SetValue(UseList[item][parm][2][0])
    3730             Indx[sizeRef.GetId()] = [item,0]
    3731             sizeRef.Bind(wx.EVT_CHECKBOX, OnRef)
    3732             isoSizer.Add(sizeRef,0,wx.ALIGN_CENTER_VERTICAL)
    3733             sizeVal = wx.TextCtrl(DData,wx.ID_ANY,
    3734                 fmt%(UseList[item][parm][1][0]),style=wx.TE_PROCESS_ENTER)
    3735             Indx[sizeVal.GetId()] = [item,0]
    3736             sizeVal.Bind(wx.EVT_TEXT_ENTER,OnVal)
    3737             sizeVal.Bind(wx.EVT_KILL_FOCUS,OnVal)
    3738             isoSizer.Add(sizeVal,0,wx.ALIGN_CENTER_VERTICAL)
    3739             return isoSizer
    3740            
    3741         def UniSizer(parm,OnAxis):
    3742             uniSizer = wx.BoxSizer(wx.HORIZONTAL)
    3743             uniSizer.Add(wx.StaticText(DData,-1,' Unique axis, H K L: '),0,wx.ALIGN_CENTER_VERTICAL)
    3744             h,k,l = UseList[item][parm][3]
    3745             Axis = wx.TextCtrl(DData,-1,'%3d %3d %3d'%(h,k,l),style=wx.TE_PROCESS_ENTER)
    3746             Indx[Axis.GetId()] = item
    3747             Axis.Bind(wx.EVT_TEXT_ENTER,OnAxis)
    3748             Axis.Bind(wx.EVT_KILL_FOCUS,OnAxis)
    3749             uniSizer.Add(Axis,0,wx.ALIGN_CENTER_VERTICAL)
    3750             return uniSizer
    3751            
    3752         def UniDataSizer(parmName,parm,fmt,OnVal,OnRef):
    3753             dataSizer = wx.BoxSizer(wx.HORIZONTAL)
    3754             parms = zip([' Equatorial '+parmName,' Axial '+parmName],
    3755                 UseList[item][parm][1],UseList[item][parm][2],range(2))
    3756             for Pa,val,ref,id in parms:
    3757                 sizeRef = wx.CheckBox(DData,-1,label=Pa)
    3758                 sizeRef.thisown = False
    3759                 sizeRef.SetValue(ref)
    3760                 Indx[sizeRef.GetId()] = [item,id]
    3761                 sizeRef.Bind(wx.EVT_CHECKBOX, OnRef)
    3762                 dataSizer.Add(sizeRef,0,wx.ALIGN_CENTER_VERTICAL)
    3763                 sizeVal = wx.TextCtrl(DData,wx.ID_ANY,fmt%(val),style=wx.TE_PROCESS_ENTER)
    3764                 Indx[sizeVal.GetId()] = [item,id]
    3765                 sizeVal.Bind(wx.EVT_TEXT_ENTER,OnVal)
    3766                 sizeVal.Bind(wx.EVT_KILL_FOCUS,OnVal)
    3767                 dataSizer.Add(sizeVal,0,wx.ALIGN_CENTER_VERTICAL)
    3768                 dataSizer.Add((5,0),0)
    3769             return dataSizer
    3770            
    3771         def EllSizeDataSizer():
    3772             parms = zip(['S11','S22','S33','S12','S13','S23'],UseList[item]['Size'][4],
    3773                 UseList[item]['Size'][5],range(6))
    3774             dataSizer = wx.FlexGridSizer(1,6,5,5)
    3775             for Pa,val,ref,id in parms:
    3776                 sizeRef = wx.CheckBox(DData,-1,label=Pa)
    3777                 sizeRef.thisown = False
    3778                 sizeRef.SetValue(ref)
    3779                 Indx[sizeRef.GetId()] = [item,id]
    3780                 sizeRef.Bind(wx.EVT_CHECKBOX, OnSizeRef)
    3781                 dataSizer.Add(sizeRef,0,wx.ALIGN_CENTER_VERTICAL)
    3782                 sizeVal = wx.TextCtrl(DData,wx.ID_ANY,'%.3f'%(val),style=wx.TE_PROCESS_ENTER)
    3783                 Indx[sizeVal.GetId()] = [item,id]
    3784                 sizeVal.Bind(wx.EVT_TEXT_ENTER,OnSizeVal)
    3785                 sizeVal.Bind(wx.EVT_KILL_FOCUS,OnSizeVal)
    3786                 dataSizer.Add(sizeVal,0,wx.ALIGN_CENTER_VERTICAL)
    3787             return dataSizer
    3788            
    3789         def GenStrainDataSizer():
    3790             Snames = G2spc.MustrainNames(SGData)
    3791             numb = len(Snames)
    3792             if len(UseList[item]['Mustrain'][4]) < numb:
    3793                 UseList[item]['Mustrain'][4] = numb*[0.0,]
    3794                 UseList[item]['Mustrain'][5] = numb*[False,]
    3795             parms = zip(Snames,UseList[item]['Mustrain'][4],UseList[item]['Mustrain'][5],range(numb))
    3796             dataSizer = wx.FlexGridSizer(1,6,5,5)
    3797             for Pa,val,ref,id in parms:
    3798                 strainRef = wx.CheckBox(DData,-1,label=Pa)
    3799                 strainRef.thisown = False
    3800                 strainRef.SetValue(ref)
    3801                 Indx[strainRef.GetId()] = [item,id]
    3802                 strainRef.Bind(wx.EVT_CHECKBOX, OnStrainRef)
    3803                 dataSizer.Add(strainRef,0,wx.ALIGN_CENTER_VERTICAL)
    3804                 strainVal = wx.TextCtrl(DData,wx.ID_ANY,'%.5f'%(val),style=wx.TE_PROCESS_ENTER)
    3805                 Indx[strainVal.GetId()] = [item,id]
    3806                 strainVal.Bind(wx.EVT_TEXT_ENTER,OnStrainVal)
    3807                 strainVal.Bind(wx.EVT_KILL_FOCUS,OnStrainVal)
    3808                 dataSizer.Add(strainVal,0,wx.ALIGN_CENTER_VERTICAL)
    3809             return dataSizer
    3810 
    3811         def HstrainSizer():
    3812             hstrainSizer = wx.FlexGridSizer(1,6,5,5)
    3813             Hsnames = G2spc.HStrainNames(SGData)
    3814             parms = zip(Hsnames,UseList[item]['HStrain'][0],UseList[item]['HStrain'][1],range(len(Hsnames)))
    3815             for Pa,val,ref,id in parms:
    3816                 hstrainRef = wx.CheckBox(DData,-1,label=Pa)
    3817                 hstrainRef.thisown = False
    3818                 hstrainRef.SetValue(ref)
    3819                 Indx[hstrainRef.GetId()] = [item,id]
    3820                 hstrainRef.Bind(wx.EVT_CHECKBOX, OnHstrainRef)
    3821                 hstrainSizer.Add(hstrainRef,0,wx.ALIGN_CENTER_VERTICAL)
    3822                 hstrainVal = wx.TextCtrl(DData,wx.ID_ANY,'%.5f'%(val),style=wx.TE_PROCESS_ENTER)
    3823                 Indx[hstrainVal.GetId()] = [item,id]
    3824                 hstrainVal.Bind(wx.EVT_TEXT_ENTER,OnHstrainVal)
    3825                 hstrainVal.Bind(wx.EVT_KILL_FOCUS,OnHstrainVal)
    3826                 hstrainSizer.Add(hstrainVal,0,wx.ALIGN_CENTER_VERTICAL)
    3827             return hstrainSizer
    3828            
    3829         def PoTopSizer(POData):
    3830             poSizer = wx.FlexGridSizer(1,6,5,5)
    3831             choice = ['March-Dollase','Spherical harmonics']
    3832             POtype = choice[['MD','SH'].index(POData[0])]
    3833             poSizer.Add(wx.StaticText(DData,-1,' Preferred orientation model '),0,wx.ALIGN_CENTER_VERTICAL)
    3834             POType = wx.ComboBox(DData,wx.ID_ANY,value=POtype,choices=choice,
    3835                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
    3836             Indx[POType.GetId()] = item
    3837             POType.Bind(wx.EVT_COMBOBOX, OnPOType)
    3838             poSizer.Add(POType)
    3839             if POData[0] == 'SH':
    3840                 poSizer.Add(wx.StaticText(DData,-1,' Harmonic order: '),0,wx.ALIGN_CENTER_VERTICAL)
    3841                 poOrder = wx.ComboBox(DData,wx.ID_ANY,value=str(POData[4]),choices=[str(2*i) for i in range(18)],
    3842                     style=wx.CB_READONLY|wx.CB_DROPDOWN)
    3843                 Indx[poOrder.GetId()] = item
    3844                 poOrder.Bind(wx.EVT_COMBOBOX,OnPOOrder)
    3845                 poSizer.Add(poOrder,0,wx.ALIGN_CENTER_VERTICAL)
    3846                 poRef = wx.CheckBox(DData,-1,label=' Refine? ')
    3847                 poRef.SetValue(POData[2])
    3848                 Indx[poRef.GetId()] = item
    3849                 poRef.Bind(wx.EVT_CHECKBOX,OnPORef)
    3850                 poSizer.Add(poRef,0,wx.ALIGN_CENTER_VERTICAL)
    3851             return poSizer
    3852            
    3853         def MDDataSizer(POData):
    3854             poSizer = wx.BoxSizer(wx.HORIZONTAL)
    3855             poRef = wx.CheckBox(DData,-1,label=' March-Dollase ratio: ')
    3856             poRef.SetValue(POData[2])
    3857             Indx[poRef.GetId()] = item
    3858             poRef.Bind(wx.EVT_CHECKBOX,OnPORef)
    3859             poSizer.Add(poRef,0,wx.ALIGN_CENTER_VERTICAL)
    3860             poVal = wx.TextCtrl(DData,wx.ID_ANY,
    3861                 '%.3f'%(POData[1]),style=wx.TE_PROCESS_ENTER)
    3862             Indx[poVal.GetId()] = item
    3863             poVal.Bind(wx.EVT_TEXT_ENTER,OnPOVal)
    3864             poVal.Bind(wx.EVT_KILL_FOCUS,OnPOVal)
    3865             poSizer.Add(poVal,0,wx.ALIGN_CENTER_VERTICAL)
    3866             poSizer.Add(wx.StaticText(DData,-1,' Unique axis, H K L: '),0,wx.ALIGN_CENTER_VERTICAL)
    3867             h,k,l =POData[3]
    3868             poAxis = wx.TextCtrl(DData,-1,'%3d %3d %3d'%(h,k,l),style=wx.TE_PROCESS_ENTER)
    3869             Indx[poAxis.GetId()] = item
    3870             poAxis.Bind(wx.EVT_TEXT_ENTER,OnPOAxis)
    3871             poAxis.Bind(wx.EVT_KILL_FOCUS,OnPOAxis)
    3872             poSizer.Add(poAxis,0,wx.ALIGN_CENTER_VERTICAL)
    3873             return poSizer
    3874            
    3875         def SHDataSizer(POData):
    3876             textJ = G2lat.textureIndex(POData[5])
    3877             mainSizer.Add(wx.StaticText(DData,-1,' Spherical harmonic coefficients: '+'Texture index: %.3f'%(textJ)),0,wx.ALIGN_CENTER_VERTICAL)
    3878             mainSizer.Add((0,5),0)
    3879             ODFSizer = wx.FlexGridSizer(2,8,2,2)
    3880             ODFIndx = {}
    3881             ODFkeys = POData[5].keys()
    3882             ODFkeys.sort()
    3883             for odf in ODFkeys:
    3884                 ODFSizer.Add(wx.StaticText(DData,-1,odf),0,wx.ALIGN_CENTER_VERTICAL)
    3885                 ODFval = wx.TextCtrl(DData,wx.ID_ANY,'%8.3f'%(POData[5][odf]),style=wx.TE_PROCESS_ENTER)
    3886                 ODFIndx[ODFval.GetId()] = odf
    3887 #                ODFval.Bind(wx.EVT_TEXT_ENTER,OnODFValue)
    3888 #                ODFval.Bind(wx.EVT_KILL_FOCUS,OnODFValue)
    3889                 ODFSizer.Add(ODFval,0,wx.ALIGN_CENTER_VERTICAL)
    3890             return ODFSizer
    3891            
    3892         def ExtSizer():           
    3893             extSizer = wx.BoxSizer(wx.HORIZONTAL)
    3894             extRef = wx.CheckBox(DData,-1,label=' Extinction: ')
    3895             extRef.SetValue(UseList[item]['Extinction'][1])
    3896             Indx[extRef.GetId()] = item
    3897             extRef.Bind(wx.EVT_CHECKBOX, OnExtRef)
    3898             extSizer.Add(extRef,0,wx.ALIGN_CENTER_VERTICAL)
    3899             extVal = wx.TextCtrl(DData,wx.ID_ANY,
    3900                 '%.2f'%(UseList[item]['Extinction'][0]),style=wx.TE_PROCESS_ENTER)
    3901             Indx[extVal.GetId()] = item
    3902             extVal.Bind(wx.EVT_TEXT_ENTER,OnExtVal)
    3903             extVal.Bind(wx.EVT_KILL_FOCUS,OnExtVal)
    3904             extSizer.Add(extVal,0,wx.ALIGN_CENTER_VERTICAL)
    3905             return extSizer
    3906        
    3907         def SCExtSizer():
    3908             extSizer = wx.BoxSizer(wx.VERTICAL)
    3909             typeSizer = wx.BoxSizer(wx.HORIZONTAL)           
    3910             typeSizer.Add(wx.StaticText(DData,-1,' Extinction type: '),0,wx.ALIGN_CENTER_VERTICAL)
    3911             Choices = ['None','Primary','Secondary Type I','Secondary Type II','Secondary Type I & II']
    3912             typeTxt = wx.ComboBox(DData,-1,choices=Choices,value=UseList[item]['Extinction'][1],
    3913                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
    3914             Indx[typeTxt.GetId()] = [item,1]
    3915             typeTxt.Bind(wx.EVT_COMBOBOX,OnSCExtType)
    3916             typeSizer.Add(typeTxt)
    3917             typeSizer.Add(wx.StaticText(DData,-1,' Approx: '),0,wx.ALIGN_CENTER_VERTICAL)
    3918             Choices=['Lorentzian','Gaussian']
    3919             approxTxT = wx.ComboBox(DData,-1,choices=Choices,value=UseList[item]['Extinction'][0],
    3920                 style=wx.CB_READONLY|wx.CB_DROPDOWN)
    3921             Indx[approxTxT.GetId()] = [item,0]
    3922             approxTxT.Bind(wx.EVT_COMBOBOX,OnSCExtType)
    3923             typeSizer.Add(approxTxT)
    3924             extSizer.Add(typeSizer,0,wx.ALIGN_CENTER_VERTICAL)
    3925             if UseList[item]['Extinction'][1] != 'None':
    3926                 extSizer.Add((0,5),)
    3927                 valSizer =wx.BoxSizer(wx.HORIZONTAL)
    3928                 valSizer.Add(wx.StaticText(DData,-1,' Tbar(mm):'),0,wx.ALIGN_CENTER_VERTICAL)
    3929                 tbarVal = wx.TextCtrl(DData,wx.ID_ANY,
    3930                     '%.3f'%(UseList[item]['Extinction'][2]['Tbar']),style=wx.TE_PROCESS_ENTER)
    3931                 Indx[tbarVal.GetId()] = item
    3932                 tbarVal.Bind(wx.EVT_TEXT_ENTER,OnTbarVal)
    3933                 tbarVal.Bind(wx.EVT_KILL_FOCUS,OnTbarVal)
    3934                 valSizer.Add(tbarVal,0,wx.ALIGN_CENTER_VERTICAL)
    3935                 valSizer.Add(wx.StaticText(DData,-1,' cos(2ThM):'),0,wx.ALIGN_CENTER_VERTICAL)
    3936                 cos2tm = wx.TextCtrl(DData,wx.ID_ANY,
    3937                     '%.3f'%(UseList[item]['Extinction'][2]['Cos2TM']),style=wx.TE_PROCESS_ENTER)
    3938                 Indx[cos2tm.GetId()] = item
    3939                 cos2tm.Bind(wx.EVT_TEXT_ENTER,OnCos2TM)
    3940                 cos2tm.Bind(wx.EVT_KILL_FOCUS,OnCos2TM)
    3941                 valSizer.Add(cos2tm,0,wx.ALIGN_CENTER_VERTICAL)
    3942                 extSizer.Add(valSizer,0,wx.ALIGN_CENTER_VERTICAL)
    3943                 val2Sizer =wx.BoxSizer(wx.HORIZONTAL)
    3944                 if 'Primary' in UseList[item]['Extinction'][1]:
    3945                     Ekey = ['Ep',]
    3946                 elif 'Secondary Type II' == UseList[item]['Extinction'][1]:
    3947                     Ekey = ['Es',]
    3948                 elif 'Secondary Type I' == UseList[item]['Extinction'][1]:
    3949                     Ekey = ['Eg',]
    3950                 else:
    3951                     Ekey = ['Eg','Es']
    3952                 for ekey in Ekey:
    3953                     Eref = wx.CheckBox(DData,-1,label=ekey+' : ')
    3954                     Eref.SetValue(UseList[item]['Extinction'][2][ekey][1])
    3955                     Indx[Eref.GetId()] = [item,ekey]
    3956                     Eref.Bind(wx.EVT_CHECKBOX, OnEref)
    3957                     val2Sizer.Add(Eref,0,wx.ALIGN_CENTER_VERTICAL)
    3958                     Eval = wx.TextCtrl(DData,wx.ID_ANY,
    3959                         '%10.3e'%(UseList[item]['Extinction'][2][ekey][0]),style=wx.TE_PROCESS_ENTER)
    3960                     Indx[Eval.GetId()] = [item,ekey]
    3961                     Eval.Bind(wx.EVT_TEXT_ENTER,OnEval)
    3962                     Eval.Bind(wx.EVT_KILL_FOCUS,OnEval)
    3963                     val2Sizer.Add(Eval,0,wx.ALIGN_CENTER_VERTICAL)
    3964    
    3965                 extSizer.Add(val2Sizer,0,wx.ALIGN_CENTER_VERTICAL)
    3966             return extSizer
    3967            
    3968         def BabSizer():
    3969             babSizer = wx.BoxSizer(wx.HORIZONTAL)
    3970             for bab in ['A','U']:
    3971                 babRef = wx.CheckBox(DData,-1,label=' Babinet '+bab+': ')
    3972                 babRef.SetValue(UseList[item]['Babinet']['Bab'+bab][1])
    3973                 Indx[babRef.GetId()] = [item,bab]
    3974                 babRef.Bind(wx.EVT_CHECKBOX, OnBabRef)
    3975                 babSizer.Add(babRef,0,wx.ALIGN_CENTER_VERTICAL)
    3976                 babVal = wx.TextCtrl(DData,wx.ID_ANY,
    3977                     '%.3f'%(UseList[item]['Babinet']['Bab'+bab][0]),style=wx.TE_PROCESS_ENTER)
    3978                 Indx[babVal.GetId()] = [item,bab]
    3979                 babVal.Bind(wx.EVT_TEXT_ENTER,OnBabVal)
    3980                 babVal.Bind(wx.EVT_KILL_FOCUS,OnBabVal)
    3981                 babSizer.Add(babVal,0,wx.ALIGN_CENTER_VERTICAL)
    3982                 babSizer.Add((5,5),0)
    3983             return babSizer
    3984            
    3985         if DData.GetSizer():
    3986             DData.GetSizer().Clear(True)
    3987         mainSizer = wx.BoxSizer(wx.VERTICAL)
    3988         mainSizer.Add(wx.StaticText(DData,-1,'Histogram data for '+PhaseName+':'),0,wx.ALIGN_CENTER_VERTICAL)
    3989         if PWDR:
    3990             mainSizer.Add(PlotSizer())           
    3991            
    3992         for item in keyList:
    3993             histData = UseList[item]
    3994             if 'Use' not in UseList[item]:      #patch
    3995                 UseList[item]['Use'] = True
    3996             if 'Babinet' not in UseList[item]:
    3997                 UseList[item]['Babinet'] = {'BabA':[0.0,False],'BabU':[0.0,False]}
    3998             showSizer = wx.BoxSizer(wx.HORIZONTAL)
    3999             showData = wx.CheckBox(DData,-1,label=' Show '+item)
    4000             showData.SetValue(UseList[item]['Show'])
    4001             Indx[showData.GetId()] = item
    4002             showData.Bind(wx.EVT_CHECKBOX, OnShowData)
    4003             showSizer.Add(showData,0,wx.ALIGN_CENTER_VERTICAL)
    4004             useData = wx.CheckBox(DData,-1,label='Use?')
    4005             Indx[useData.GetId()] = item
    4006             showSizer.Add(useData,0,wx.ALIGN_CENTER_VERTICAL)
    4007             useData.Bind(wx.EVT_CHECKBOX, OnUseData)
    4008             useData.SetValue(UseList[item]['Use'])
    4009             copyData = wx.Button(DData,-1,label=' Copy?')
    4010             Indx[copyData.GetId()] = item
    4011             copyData.Bind(wx.EVT_BUTTON,OnCopyData)
    4012             showSizer.Add(copyData,wx.ALIGN_CENTER_VERTICAL)
    4013             copyFlags = wx.Button(DData,-1,label=' Copy flags?')
    4014             Indx[copyFlags.GetId()] = item
    4015             copyFlags.Bind(wx.EVT_BUTTON,OnCopyFlags)
    4016             showSizer.Add(copyFlags,wx.ALIGN_CENTER_VERTICAL)
    4017             mainSizer.Add((5,5),0)
    4018             mainSizer.Add(showSizer,0,wx.ALIGN_CENTER_VERTICAL)
    4019             mainSizer.Add((0,5),0)
    4020            
    4021             if UseList[item]['Show']:
    4022                 mainSizer.Add(ScaleSizer())
    4023                 mainSizer.Add((0,5),0)
    4024                
    4025             if item[:4] == 'PWDR' and UseList[item]['Show']:
    4026                 if UseList[item]['Size'][0] == 'isotropic':
    4027                     isoSizer = wx.BoxSizer(wx.HORIZONTAL)
    4028                     isoSizer.Add(TopSizer(' Size model: ',['isotropic','uniaxial','ellipsoidal'],
    4029                         'Size',OnSizeType),0,wx.ALIGN_CENTER_VERTICAL)
    4030                     isoSizer.Add(LGmixSizer('Size',OnLGmixVal,OnLGmixRef))
    4031                     isoSizer.Add(ResetSizer('isotropic',OnResetSize),0,wx.ALIGN_CENTER_VERTICAL)
    4032                     mainSizer.Add(isoSizer)
    4033                     mainSizer.Add(IsoSizer(u' Cryst. size(\xb5m): ','Size','%.3f',
    4034                         OnSizeVal,OnSizeRef),0,wx.ALIGN_CENTER_VERTICAL)
    4035                 elif UseList[item]['Size'][0] == 'uniaxial':
    4036                     uniSizer = wx.BoxSizer(wx.HORIZONTAL)
    4037                     uniSizer.Add(TopSizer(' Size model: ',['isotropic','uniaxial','ellipsoidal'],
    4038                         'Size',OnSizeType),0,wx.ALIGN_CENTER_VERTICAL)
    4039                     uniSizer.Add(LGmixSizer('Size',OnLGmixVal,OnLGmixRef))
    4040                     uniSizer.Add(ResetSizer('uniaxial',OnResetSize),0,wx.ALIGN_CENTER_VERTICAL)
    4041                     mainSizer.Add(UniSizer('Size',OnSizeAxis),0,wx.ALIGN_CENTER_VERTICAL)
    4042                     mainSizer.Add(uniSizer)
    4043                     mainSizer.Add(UniDataSizer(u'size(\xb5m): ','Size','%.3f',OnSizeVal,OnSizeRef))
    4044                 elif UseList[item]['Size'][0] == 'ellipsoidal':
    4045                     ellSizer = wx.BoxSizer(wx.HORIZONTAL)
    4046                     ellSizer.Add(TopSizer(' Size model: ',['isotropic','uniaxial','ellipsoidal'],
    4047                         'Size',OnSizeType),0,wx.ALIGN_CENTER_VERTICAL)
    4048                     ellSizer.Add(LGmixSizer('Size',OnLGmixVal,OnLGmixRef))
    4049                     ellSizer.Add(ResetSizer('ellipsoidal',OnResetSize),0,wx.ALIGN_CENTER_VERTICAL)
    4050                     mainSizer.Add(ellSizer)
    4051                     mainSizer.Add(EllSizeDataSizer())
    4052                 mainSizer.Add((0,5),0)                   
    4053                
    4054                 if UseList[item]['Mustrain'][0] == 'isotropic':
    4055                     isoSizer = wx.BoxSizer(wx.HORIZONTAL)
    4056                     isoSizer.Add(TopSizer(' Mustrain model: ',['isotropic','uniaxial','generalized',],
    4057                         'Mustrain',OnStrainType),0,wx.ALIGN_CENTER_VERTICAL)
    4058                     isoSizer.Add(LGmixSizer('Mustrain',OnLGmixVal,OnLGmixRef))
    4059                     isoSizer.Add(ResetSizer('isotropic',OnResetStrain),0,wx.ALIGN_CENTER_VERTICAL)
    4060                     mainSizer.Add(isoSizer)
    4061                     mainSizer.Add(IsoSizer(' microstrain: ','Mustrain','%.1f',
    4062                         OnStrainVal,OnStrainRef),0,wx.ALIGN_CENTER_VERTICAL)                   
    4063                     mainSizer.Add((0,5),0)
    4064                 elif UseList[item]['Mustrain'][0] == 'uniaxial':
    4065                     uniSizer = wx.BoxSizer(wx.HORIZONTAL)
    4066                     uniSizer.Add(TopSizer(' Mustrain model: ',['isotropic','uniaxial','generalized',],
    4067                         'Mustrain',OnStrainType),0,wx.ALIGN_CENTER_VERTICAL)
    4068                     uniSizer.Add(LGmixSizer('Mustrain',OnLGmixVal,OnLGmixRef))
    4069                     uniSizer.Add(ResetSizer('uniaxial',OnResetStrain),0,wx.ALIGN_CENTER_VERTICAL)
    4070                     mainSizer.Add(uniSizer)
    4071                     mainSizer.Add(UniSizer('Mustrain',OnStrainAxis),0,wx.ALIGN_CENTER_VERTICAL)
    4072                     mainSizer.Add(UniDataSizer('mustrain: ','Mustrain','%.1f',OnStrainVal,OnStrainRef))
    4073                 elif UseList[item]['Mustrain'][0] == 'generalized':
    4074                     genSizer = wx.BoxSizer(wx.HORIZONTAL)
    4075                     genSizer.Add(TopSizer(' Mustrain model: ',['isotropic','uniaxial','generalized',],
    4076                         'Mustrain',OnStrainType),0,wx.ALIGN_CENTER_VERTICAL)
    4077                     genSizer.Add(LGmixSizer('Mustrain',OnLGmixVal,OnLGmixRef))
    4078                     genSizer.Add(ResetSizer('generalized',OnResetStrain),0,wx.ALIGN_CENTER_VERTICAL)
    4079                     mainSizer.Add(genSizer)
    4080                     mainSizer.Add(GenStrainDataSizer())                       
    4081                 mainSizer.Add((0,5),0)
    4082                
    4083                 mainSizer.Add(wx.StaticText(DData,-1,' Hydrostatic/elastic strain:'))
    4084                 mainSizer.Add(HstrainSizer())
    4085                    
    4086                 #texture  'Pref. Ori.':['MD',1.0,False,[0,0,1],0,[]] last two for 'SH' are SHorder & coeff
    4087                 poSizer = wx.BoxSizer(wx.VERTICAL)
    4088                 POData = UseList[item]['Pref.Ori.']
    4089                 poSizer.Add(PoTopSizer(POData))
    4090                 if POData[0] == 'MD':
    4091                     poSizer.Add(MDDataSizer(POData))
    4092                 else:           #'SH'
    4093                     if POData[4]:       #SH order > 0
    4094                         poSizer.Add(SHDataSizer(POData))
    4095                        
    4096                 mainSizer.Add(poSizer)
    4097                 mainSizer.Add((0,5),0)               
    4098                 mainSizer.Add(ExtSizer())
    4099                 mainSizer.Add((0,5),0)
    4100                 mainSizer.Add(BabSizer())
    4101                 mainSizer.Add((0,5),0)
    4102             elif item[:4] == 'HKLF' and UseList[item]['Show']:
    4103                 mainSizer.Add((0,5),0)               
    4104                 mainSizer.Add(SCExtSizer())
    4105                 mainSizer.Add((0,5),0)
    4106                 mainSizer.Add(BabSizer())
    4107                 mainSizer.Add((0,5),0)
    4108                 pass
    4109             mainSizer.Add(wx.StaticText(DData,-1,150*'-'),0,)
    4110         mainSizer.Add((5,5),0)
    4111 
    4112         DData.SetSizer(mainSizer,True)
    4113         mainSizer.FitInside(G2frame.dataFrame)
    4114         Size = mainSizer.GetMinSize()
    4115         Size[0] += 40
    4116         Size[1] = max(Size[1],290) + 35
    4117         DData.SetSize(Size)
    4118         DData.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
    4119         Size[1] = min(Size[1],450)
    4120         G2frame.dataFrame.setSizePosLeft(Size)
    41212865       
    41222866    def OnHklfAdd(event):
     
    41452889                    UpdateHKLFdata(histoName)
    41462890                    wx.EndBusyCursor()
    4147                     wx.CallAfter(UpdateDData)
     2891                    wx.CallAfter(G2ddG.UpdateDData,G2frame,DData,data)
    41482892            finally:
    41492893                dlg.Destroy()
     
    41982942                        refList[generalData['Name']] = []                       
    41992943                    data['Histograms'] = UseList
    4200                     wx.CallAfter(UpdateDData)
     2944                    wx.CallAfter(G2ddG.UpdateDData,G2frame,DData,data)
    42012945            finally:
    42022946                dlg.Destroy()
     
    42212965                    for i in DelList:
    42222966                        del UseList[i]
    4223                     wx.CallAfter(UpdateDData)
     2967                    wx.CallAfter(G2ddG.UpdateDData,G2frame,DData,data)
    42242968            finally:
    42252969                dlg.Destroy()
     
    42302974
    42312975    def FillRigidBodyGrid():
     2976        AtLookUp = G2mth.FillAtomLookUp(data['Atoms'])
     2977        general = data['General']
     2978        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
     2979        Indx = {}
     2980       
     2981        def ResrbSizer(RBObj):
     2982           
     2983            def OnOrigRef(event):
     2984                RBObj['Orig'][1] = Ocheck.GetValue()
     2985             
     2986            def OnOrienRef(event):
     2987                RBObj['Orient'][1] = Qcheck.GetValue()
     2988               
     2989            def OnTorsionRef(event):
     2990                Obj = event.GetEventObject()
     2991                item = Indx[Obj.GetId()]
     2992                RBObj['Torsions'][item][1] = Obj.GetValue()               
     2993               
     2994            def OnTorsion(event):
     2995                Obj = event.GetEventObject()
     2996                item = Indx[Obj.GetId()]
     2997                try:
     2998                    val = float(Obj.GetValue())
     2999                    RBObj['Torsions'][item][0] = val
     3000                    RBData = G2frame.PatternTree.GetItemPyData(   
     3001                        G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))['Residue']
     3002                    G2mth.UpdateResRBAtoms(Amat,Bmat,data['Atoms'],AtLookUp,RBObj,RBData)
     3003                except ValueError:
     3004                    pass
     3005                Obj.SetValue("%10.3f"%(RBObj['Torsions'][item][0]))               
     3006             
     3007            resrbSizer = wx.BoxSizer(wx.VERTICAL)
     3008            resrbSizer.Add(wx.StaticText(RigidBodies,-1,120*'-'))
     3009            resrbSizer.Add(wx.StaticText(RigidBodies,-1,
     3010                'Name: '+RBObj['ResName']+RBObj['numChain']),0,wx.ALIGN_CENTER_VERTICAL)
     3011            topSizer = wx.FlexGridSizer(2,2,5,5)
     3012            Orig = RBObj['Orig'][0]
     3013            Orien = RBObj['Orient'][0]
     3014            topSizer.Add(wx.StaticText(RigidBodies,-1,
     3015                ' %s %8.5f %8.5f %8.5f'%(       'Origin     :',Orig[0],Orig[1],Orig[2])))
     3016            Ocheck = wx.CheckBox(RigidBodies,-1,'Refine?')
     3017            Ocheck.Bind(wx.EVT_CHECKBOX,OnOrigRef)
     3018            Ocheck.SetValue(RBObj['Orig'][1])
     3019            topSizer.Add(Ocheck,0,wx.ALIGN_CENTER_VERTICAL)
     3020            topSizer.Add(wx.StaticText(RigidBodies,-1,
     3021                ' %s %8.5f %8.5f %8.5f %8.5f '%('Orientation:',Orien[0],Orien[1],Orien[2],Orien[3])))
     3022            Qcheck = wx.CheckBox(RigidBodies,-1,'Refine?')
     3023            Qcheck.Bind(wx.EVT_CHECKBOX,OnOrienRef)
     3024            Qcheck.SetValue(RBObj['Orient'][1])
     3025            topSizer.Add(Qcheck,0,wx.ALIGN_CENTER_VERTICAL)
     3026            resrbSizer.Add(topSizer)
     3027            resrbSizer.Add(wx.StaticText(RigidBodies,-1,' Torsions:'),0,wx.ALIGN_CENTER_VERTICAL)
     3028            torSizer = wx.FlexGridSizer(1,6,5,5)
     3029            for itors,tors in enumerate(RBObj['Torsions']):
     3030                torSizer.Add(wx.StaticText(RigidBodies,-1,'Torsion '+'%d'%(itors)),0,wx.ALIGN_CENTER_VERTICAL)
     3031                torsTxt = wx.TextCtrl(RigidBodies,-1,value='%.3f'%(tors[0]),style=wx.TE_PROCESS_ENTER)
     3032                torsTxt.Bind(wx.EVT_TEXT_ENTER,OnTorsion)
     3033                torsTxt.Bind(wx.EVT_KILL_FOCUS,OnTorsion)
     3034                Indx[torsTxt.GetId()] = itors
     3035                torSizer.Add(torsTxt)
     3036                torCheck = wx.CheckBox(RigidBodies,-1,'Refine?')
     3037                torCheck.Bind(wx.EVT_CHECKBOX,OnTorsionRef)
     3038                torCheck.SetValue(tors[1])
     3039                Indx[torCheck.GetId()] = itors
     3040                torSizer.Add(torCheck,0,wx.ALIGN_CENTER_VERTICAL)
     3041            resrbSizer.Add(torSizer)
     3042            return resrbSizer       
     3043       
    42323044        G2frame.dataFrame.SetStatusText('')
    4233         RigidBodies.DestroyChildren()
    4234         dataDisplay = wx.Panel(RigidBodies)
    42353045        mainSizer = wx.BoxSizer(wx.VERTICAL)
    4236         mainSizer.Add((5,5),0)
    4237         mainSizer.Add(wx.StaticText(dataDisplay,-1,' :'),0,wx.ALIGN_CENTER_VERTICAL)
    4238         mainSizer.Add((5,5),0)       
    4239 #        mainSizer.Add(SlopSizer(),0)
    4240 #        mainSizer.Add((5,5),0)
    4241 #        mainSizer.Add(ShowSizer(),0,)
    4242 #        mainSizer.Add((5,5),0)
    4243 #        mainSizer.Add(RadSizer(),0,)
    4244 
    4245         dataDisplay.SetSizer(mainSizer)
    4246         Size = mainSizer.Fit(G2frame.dataFrame)
    4247         Size[1] += 35                           #compensate for status bar
    4248         dataDisplay.SetSize(Size)
     3046        if 'Residue' in data['RBModels']:
     3047            mainSizer.Add((5,5),0)
     3048            mainSizer.Add(wx.StaticText(RigidBodies,-1,'Residue rigid bodies:'),0,wx.ALIGN_CENTER_VERTICAL)
     3049            mainSizer.Add((5,5),0)
     3050            for RBObj in data['RBModels']['Residue']:
     3051                mainSizer.Add(ResrbSizer(RBObj))
     3052
     3053        RigidBodies.SetSizer(mainSizer)
     3054        mainSizer.FitInside(G2frame.dataFrame)
     3055        Size = mainSizer.GetMinSize()
     3056        Size[0] += 40
     3057        Size[1] = max(Size[1],290) + 35
     3058        RigidBodies.SetSize(Size)
     3059        RigidBodies.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
     3060        Size[1] = min(Size[1],450)
    42493061        G2frame.dataFrame.setSizePosLeft(Size)
     3062               
     3063    def OnAutoFindResRB(event):
     3064        RBData = G2frame.PatternTree.GetItemPyData(   
     3065            G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))['Residue']
     3066        rbKeys = RBData.keys()
     3067        rbKeys.remove('AtInfo')
     3068        if not len(rbKeys):
     3069            print '**** ERROR - no residue rigid bodies are defined ****'
     3070            return
     3071        RBNames = [RBData[k]['RBname'] for k in rbKeys]
     3072        RBIds = dict(zip(RBNames,rbKeys))
     3073        general = data['General']
     3074        Amat,Bmat = G2lat.cell2AB(general['Cell'][1:7])
     3075        Atoms = data['Atoms']
     3076        AtLookUp = G2mth.FillAtomLookUp(Atoms)
     3077        if 'macro' not in general['Type']:
     3078            print '**** ERROR - this phase is not a macromolecule ****'
     3079            return
     3080        if not len(Atoms):
     3081            print '**** ERROR - this phase has no atoms ****'
     3082            return
     3083        RBObjs = []
     3084        cx,ct = general['AtomPtrs'][:2]
     3085        iatm = 0
     3086        wx.BeginBusyCursor()
     3087        try:
     3088            while iatm < len(Atoms):
     3089                atom = Atoms[iatm]
     3090                res = atom[1].strip()
     3091                numChain = ' %s %s'%(atom[0],atom[2])
     3092                if res not in RBIds:
     3093                    iatm += 1
     3094                    continue        #for water molecules, etc.
     3095                rbRes = RBData[RBIds[res]]
     3096                rbRef = rbRes['rbRef']
     3097                VAR = rbRes['rbXYZ'][rbRef[1]]-rbRes['rbXYZ'][rbRef[0]]
     3098                VBR = rbRes['rbXYZ'][rbRef[2]]-rbRes['rbXYZ'][rbRef[0]]
     3099                rbObj = {'ResName':rbRes['RBname'],'numChain':numChain}
     3100                rbAtoms = []
     3101                rbIds = []
     3102                for iratm in range(len(rbRes['atNames'])):
     3103                    rbAtoms.append(np.array(Atoms[iatm][cx:cx+3]))
     3104                    rbIds.append(Atoms[iatm][20])
     3105                    iatm += 1    #puts this at beginning of next residue?
     3106                Orig = rbAtoms[rbRef[0]]
     3107                rbObj['Ids'] = rbIds
     3108                rbObj['Orig'] = [Orig,False]
     3109    #            print ' residue '+rbRes['RBname']+str(atom[0]).strip()+ \
     3110    #                ' origin at: ','%.5f %.5f %.5f'%(Orig[0],Orig[1],Orig[2])
     3111                VAC = np.inner(Amat,rbAtoms[rbRef[1]]-Orig)
     3112                VBC = np.inner(Amat,rbAtoms[rbRef[2]]-Orig)
     3113                VCC = np.cross(VAR,VAC)
     3114                QuatA = G2mth.makeQuat(VAR,VAC,VCC)[0]
     3115                VAR = G2mth.prodQVQ(QuatA,VAR)
     3116                VBR = G2mth.prodQVQ(QuatA,VBR)
     3117                QuatB = G2mth.makeQuat(VBR,VBC,VAR)[0]
     3118                QuatC = G2mth.prodQQ(QuatB,QuatA)
     3119                rbObj['Orient'] = [QuatC,False]
     3120                SXYZ = []
     3121                TXYZ = []
     3122                rbObj['Torsions'] = []
     3123                for i,xyz in enumerate(rbRes['rbXYZ']):
     3124                    SXYZ.append(G2mth.prodQVQ(QuatC,xyz))               
     3125                    TXYZ.append(np.inner(Amat,rbAtoms[i]-Orig))
     3126                for Oatm,Patm,x,Riders in rbRes['rbSeq']:
     3127                    VBR = SXYZ[Oatm]-SXYZ[Patm]
     3128                    VAR = SXYZ[Riders[0]]-SXYZ[Patm]
     3129                    VAC = TXYZ[Riders[0]]-TXYZ[Patm]
     3130                    QuatA,D = G2mth.makeQuat(VAR,VAC,VBR)
     3131                    ang = 180.*D/np.pi
     3132                    rbObj['Torsions'].append([ang,False])
     3133                    for ride in Riders:
     3134                        SXYZ[ride] = G2mth.prodQVQ(QuatA,SXYZ[ride]-SXYZ[Patm])+SXYZ[Patm]
     3135                RBObjs.append(rbObj)
     3136            data['RBModels']['Residue'] = RBObjs
     3137            for RBObj in RBObjs:
     3138                G2mth.UpdateResRBAtoms(Amat,Bmat,Atoms,AtLookUp,RBObj,RBData)
     3139        finally:
     3140            wx.EndBusyCursor()
     3141        FillRigidBodyGrid()
    42503142       
     3143    def OnGlobalResRBRef(event):
     3144        RBObjs = data['RBModels']['Residue']
     3145        names = ['Origin','Orientation',]
     3146        nTor = 0
     3147        for rbObj in RBObjs:
     3148            nTor = max(nTor,len(rbObj['Torsions']))
     3149        names += ['Torsion '+str(i) for i in range(nTor)]
     3150        dlg = wx.MultiChoiceDialog(G2frame,'Select','Refinement controls',names)
     3151        if dlg.ShowModal() == wx.ID_OK:
     3152            sel = dlg.GetSelections()
     3153            parms = []
     3154            for x in sel:
     3155                parms.append(names[x])
     3156            wx.BeginBusyCursor()
     3157            try:
     3158                for rbObj in RBObjs:
     3159                    if 'Origin' in parms:
     3160                        rbObj['Orig'][1] = True
     3161                    else:
     3162                        rbObj['Orig'][1] = False
     3163                    if 'Orientation' in parms:
     3164                        rbObj['Orient'][1] = True
     3165                    else:
     3166                        rbObj['Orient'][1] = False
     3167                    for i in range(len(rbObj['Torsions'])):
     3168                        if 'Torsion '+str(i) in parms:
     3169                            rbObj['Torsions'][i][1] = True
     3170                        else:
     3171                            rbObj['Torsions'][i][1] = False           
     3172            finally:
     3173                wx.EndBusyCursor()
     3174            FillRigidBodyGrid()
     3175                       
    42513176
    42523177################################################################################
     
    47213646            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomAdd, id=G2gd.wxID_ATOMSEDITADD)
    47223647            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewAdd, id=G2gd.wxID_ATOMSVIEWADD)
     3648            G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBAppend, id=G2gd.wxID_RBAPPEND)
    47233649            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomInsert, id=G2gd.wxID_ATOMSEDITINSERT)
    47243650            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomViewInsert, id=G2gd.wxID_ATOMVIEWINSERT)
     3651            G2frame.dataFrame.Bind(wx.EVT_MENU, OnRBAssign, id=G2gd.wxID_ASSIGNATMS2RB)
    47253652            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAtomMove, id=G2gd.wxID_ATOMMOVE)
    47263653            G2frame.dataFrame.Bind(wx.EVT_MENU, AtomDelete, id=G2gd.wxID_ATOMSEDITDELETE)
     
    47303657            G2frame.dataFrame.Bind(wx.EVT_MENU, OnReloadDrawAtoms, id=G2gd.wxID_RELOADDRAWATOMS)
    47313658            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDistAngle, id=G2gd.wxID_ATOMSDISAGL)
    4732             FillAtomsGrid()
     3659            FillAtomsGrid(Atoms)
    47333660        elif text == 'General':
    47343661            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.DataGeneral)
     
    47433670            G2frame.dataFrame.Bind(wx.EVT_MENU, OnHklfAdd, id=G2gd.wxID_HKLFADD)
    47443671            G2frame.dataFrame.Bind(wx.EVT_MENU, OnDataDelete, id=G2gd.wxID_DATADELETE)
    4745             UpdateDData()
     3672            G2ddG.UpdateDData(G2frame,DData,data)
    47463673            G2plt.PlotSizeStrainPO(G2frame,data,Start=True)
    47473674        elif text == 'Draw Options':
     
    47713698            UpdateDrawAtoms()
    47723699            G2plt.PlotStructure(G2frame,data)
    4773         elif text == 'Rigid bodies':
    4774             G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodyMenu)
    4775            
    4776            
     3700        elif text == 'RB Models':
     3701            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.RigidBodiesMenu)
     3702            G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoFindResRB, id=G2gd.wxID_AUTOFINDRESRB)
     3703            G2frame.dataFrame.Bind(wx.EVT_MENU, OnGlobalResRBRef, id=G2gd.wxID_GLOBALRESREFINE)
    47773704            FillRigidBodyGrid()
    47783705        elif text == 'Pawley reflections':
     
    48273754    G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
    48283755    RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
    4829     G2frame.dataDisplay.AddPage(RigidBodies,'Rigid bodies')
     3756    G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
    48303757    MapPeaks = G2gd.GSGrid(G2frame.dataDisplay)
    48313758    G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
     
    48373764    G2frame.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
    48383765    G2frame.dataDisplay.SetSelection(oldPage)
     3766
  • trunk/GSASIIrestrGUI.py

    r825 r848  
    1818import GSASIImath as G2mth
    1919import GSASIIlattice as G2lat
    20 import GSASIIphsGUI as G2phG
    2120import GSASIIspc as G2spc
    2221import GSASIIgrid as G2gd
     
    321320        if len(Lists['B-atom']):
    322321            value = 109.54
    323             dlg = G2phG.SingleFloatDialog(G2frame,'Angle','Enter restraint angle ',value,[30.,180.],'%.2f')
     322            dlg = G2gd.SingleFloatDialog(G2frame,'Angle','Enter restraint angle ',value,[30.,180.],'%.2f')
    324323            if dlg.ShowModal() == wx.ID_OK:
    325324                value = dlg.GetValue()
     
    703702            if len(ids) > 2:
    704703                value = 1.0
    705                 dlg = G2phG.SingleFloatDialog(G2frame,'Angle','Enter unit cell sum ',value,[-1.e6,1.e6],'%.2f')
     704                dlg = G2gd.SingleFloatDialog(G2frame,'Angle','Enter unit cell sum ',value,[-1.e6,1.e6],'%.2f')
    706705                if dlg.ShowModal() == wx.ID_OK:
    707706                    value = dlg.GetValue()               
     
    817816            Bonds.ClearSelection()
    818817            val = bondList[rows[0]][2]
    819             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new value for bond',val,[0.,5.],'%.4f')
     818            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for bond',val,[0.,5.],'%.4f')
    820819            if dlg.ShowModal() == wx.ID_OK:
    821820                parm = dlg.GetValue()
     
    831830            Bonds.ClearSelection()
    832831            val = bondList[rows[0]][3]
    833             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new esd for bond',val,[0.,1.],'%.4f')
     832            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for bond',val,[0.,1.],'%.4f')
    834833            if dlg.ShowModal() == wx.ID_OK:
    835834                parm = dlg.GetValue()
     
    941940            Angles.ClearSelection()
    942941            val = angleList[rows[0]][2]
    943             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new value for angle',val,[0.,360.],'%.2f')
     942            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for angle',val,[0.,360.],'%.2f')
    944943            if dlg.ShowModal() == wx.ID_OK:
    945944                parm = dlg.GetValue()
     
    955954            Angles.ClearSelection()
    956955            val = angleList[rows[0]][3]
    957             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new esd for angle',val,[0.,5.],'%.2f')
     956            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for angle',val,[0.,5.],'%.2f')
    958957            if dlg.ShowModal() == wx.ID_OK:
    959958                parm = dlg.GetValue()
     
    10691068            Planes.ClearSelection()
    10701069            val = planeList[rows[0]][3]
    1071             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new esd for plane',val,[0.,5.],'%.2f')
     1070            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for plane',val,[0.,5.],'%.2f')
    10721071            if dlg.ShowModal() == wx.ID_OK:
    10731072                parm = dlg.GetValue()
     
    11941193            Volumes.ClearSelection()
    11951194            val = volumeList[rows[0]][2]
    1196             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new value for chiral volume',val,[0.,360.],'%.2f')
     1195            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new value for chiral volume',val,[0.,360.],'%.2f')
    11971196            if dlg.ShowModal() == wx.ID_OK:
    11981197                parm = dlg.GetValue()
     
    12081207            Volumes.ClearSelection()
    12091208            val = volumeList[rows[0]][3]
    1210             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new esd for chiral volume',val,[0.,5.],'%.2f')
     1209            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for chiral volume',val,[0.,5.],'%.2f')
    12111210            if dlg.ShowModal() == wx.ID_OK:
    12121211                parm = dlg.GetValue()
     
    13171316            Torsions.ClearSelection()
    13181317            val = torsionList[rows[0]][4]
    1319             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new esd for torsion restraints',val,[0.,5.],'%.2f')
     1318            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for torsion restraints',val,[0.,5.],'%.2f')
    13201319            if dlg.ShowModal() == wx.ID_OK:
    13211320                parm = dlg.GetValue()
     
    14321431            Ramas.ClearSelection()
    14331432            val = ramaList[rows[0]][4]
    1434             dlg = G2phG.SingleFloatDialog(G2frame,'New value','Enter new esd for energy',val,[0.,5.],'%.2f')
     1433            dlg = G2gd.SingleFloatDialog(G2frame,'New value','Enter new esd for energy',val,[0.,5.],'%.2f')
    14351434            if dlg.ShowModal() == wx.ID_OK:
    14361435                parm = dlg.GetValue()
     
    15581557                return
    15591558            ChemComps.ClearSelection()
    1560             dlg = G2phG.SingleFloatDialog(G2frame,'New value',
     1559            dlg = G2gd.SingleFloatDialog(G2frame,'New value',
    15611560                'Enter new value for restraint multiplier',1.0,[-1.e6,1.e6],'%.2f')
    15621561            if dlg.ShowModal() == wx.ID_OK:
  • trunk/GSASIIstruct.py

    r847 r848  
    39003900                ncyc = int(result[2]['nfev']/len(varyList))
    39013901
    3902 
    3903 
    39043902            runtime = time.time()-begin
    39053903            Rvals['chisq'] = np.sum(result[2]['fvec']**2)
Note: See TracChangeset for help on using the changeset viewer.