Changeset 3565


Ignore:
Timestamp:
Aug 21, 2018 3:47:14 PM (3 years ago)
Author:
vondreele
Message:

G2ctrls: change MultiFloatDialog? to accept bool arguments - maybe ints & strings could be added?
now used only for setup of Bilbao runs
G2phaseGUI: Add selection menu item the Phase/General? to select from Bilbao derived magnetic phase list
remove Bilbao call from TransformDialogG2pwdr: make getHKLpeak return np.array instead of list - that's how HKLs are used everywhere
G2pwdrGUI: show Bilbao results as table in Unit Cells List - selection shows peak indexing; Keep allows future use in making new magnetic phase.
Add menu item in Unit Cells List to call Bilbao k-SUBGROUPSMAG routineG2spc: Revise TextGen? & make new routine GetOprNames?

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIctrlGUI.py

    r3561 r3565  
    22522252################################################################################
    22532253class MultiFloatDialog(wx.Dialog):
    2254     'Dialog to obtain a multi float value from user'
     2254    'Dialog to obtain multiple values from user'
    22552255    def __init__(self,parent,title,prompts,values,limits=[[0.,1.],],formats=['%.5g',]):
    22562256        wx.Dialog.__init__(self,parent,-1,title,
     
    22692269            Obj = event.GetEventObject()
    22702270            id,limits,format = Indx[Obj]
    2271             try:
    2272                 val = float(Obj.GetValue())
    2273                 if val < limits[0] or val > limits[1]:
    2274                     raise ValueError
    2275             except ValueError:
    2276                 val = self.values[id]
    2277             self.values[id] = val
    2278             Obj.SetValue(format%(val))
     2271            if 'bool' in format:
     2272                self.values[id] = Obj.GetValue()
     2273            else:
     2274                try:
     2275                    val = float(Obj.GetValue())
     2276                    if val < limits[0] or val > limits[1]:
     2277                        raise ValueError
     2278                except ValueError:
     2279                    val = self.values[id]
     2280                self.values[id] = val
     2281                Obj.SetValue(format%(val))
    22792282           
    22802283        Indx = {}
     
    22852288        for id,[prompt,value,limits,format] in enumerate(zip(self.prompts,self.values,self.limits,self.formats)):
    22862289            lineSizer.Add(wx.StaticText(self.panel,label=prompt),0,wx.ALIGN_CENTER)
    2287             valItem = wx.TextCtrl(self.panel,value=format%(value),style=wx.TE_PROCESS_ENTER)
     2290            if 'bool' in format:
     2291                valItem = wx.CheckBox(self.panel,label='')
     2292                valItem.Bind(wx.EVT_CHECKBOX,OnValItem)
     2293                valItem.SetValue(value)
     2294            else:
     2295                valItem = wx.TextCtrl(self.panel,value=format%(value),style=wx.TE_PROCESS_ENTER)
     2296                valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
     2297                valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
    22882298            Indx[valItem] = [id,limits,format]
    22892299            lineSizer.Add(valItem,0,wx.ALIGN_CENTER)
    2290             valItem.Bind(wx.EVT_TEXT_ENTER,OnValItem)
    2291             valItem.Bind(wx.EVT_KILL_FOCUS,OnValItem)
    22922300        mainSizer.Add(lineSizer)
    22932301        OkBtn = wx.Button(self.panel,-1,"Ok")
  • trunk/GSASIIdataGUI.py

    r3560 r3565  
    27052705        self.ExpandingAll = False
    27062706        self.SeqTblHideList = None
    2707         self.MagPhases = False      #will contain possible magnetic phases from Bilbao MAXMAGN
    27082707        self.lastSelectedPhaseTab = None # track the last tab pressed on a phase window
    27092708       
     
    50055004        # PDR / Unit Cells List
    50065005        G2G.Define_wxId('wxID_INDEXPEAKS', 'wxID_REFINECELL', 'wxID_COPYCELL', 'wxID_MAKENEWPHASE',
    5007             'wxID_EXPORTCELLS','wxID_LOADCELL','wxID_IMPORTCELL','wxID_TRANSFORMCELL')
     5006            'wxID_EXPORTCELLS','wxID_LOADCELL','wxID_IMPORTCELL','wxID_TRANSFORMCELL','wxID_RUNSUBMAG')
    50085007        self.IndexMenu = wx.MenuBar()
    50095008        self.PrefillDataMenu(self.IndexMenu)
    50105009        self.IndexEdit = wx.Menu(title='')
    50115010        self.IndexMenu.Append(menu=self.IndexEdit, title='Cell Index/Refine')
    5012         self.IndexPeaks = self.IndexEdit.Append(G2G.wxID_INDEXPEAKS,'Index Cell','')
     5011        self.IndexPeaks = self.IndexEdit.Append(G2G.wxID_INDEXPEAKS,'Index Cell',
     5012            'Find cells that index fitted peaks')
     5013        self.RunSubGroupsMag = self.IndexEdit.Append(G2G.wxID_RUNSUBMAG,'Run k-SUBGROUPMAG',
     5014            'If disabled, do Load Cell first')
    50135015        self.CopyCell = self.IndexEdit.Append(G2G.wxID_COPYCELL,'Copy Cell',
    50145016            'Copy selected unit cell from indexing to cell refinement fields')
     
    50265028        self.PostfillDataMenu()
    50275029        self.IndexPeaks.Enable(False)
     5030        self.RunSubGroupsMag.Enable(False)
    50285031        self.CopyCell.Enable(False)
    50295032        self.RefineCell.Enable(False)
     
    51985201        # Phase / General tab
    51995202        G2G.Define_wxId('wxID_FOURCALC', 'wxID_FOURSEARCH', 'wxID_FOURCLEAR','wxID_CHARGEFLIP','wxID_VALIDPROTEIN',
    5200             'wxID_MULTIMCSA','wxID_SINGLEMCSA', 'wxID_4DCHARGEFLIP', 'wxID_TRANSFORMSTRUCTURE',)
     5203            'wxID_MULTIMCSA','wxID_SINGLEMCSA', 'wxID_4DCHARGEFLIP', 'wxID_TRANSFORMSTRUCTURE','wxID_USEBILBAOMAG',)
    52015204        self.DataGeneral = wx.MenuBar()
    52025205        self.PrefillDataMenu(self.DataGeneral)
     
    52135216        self.GeneralCalc.Append(G2G.wxID_MULTIMCSA,'Multi MC/SA','Run Monte Carlo - Simulated Annealing on multiprocessors')
    52145217        self.GeneralCalc.Append(G2G.wxID_TRANSFORMSTRUCTURE,'Transform','Transform crystal structure')
     5218        self.GeneralCalc.Append(G2G.wxID_USEBILBAOMAG,'Select magnetic phase','If disabled, make in PWDR/Unit Cells')       
    52155219        self.GeneralCalc.Append(G2G.wxID_VALIDPROTEIN,'Protein quality','Protein quality analysis')
    52165220        self.PostfillDataMenu()
     
    78817885            data.append([])                                 #empty dmin
    78827886            data.append({})                                 #empty superlattice stuff
     7887            data.append([])                                 #empty mag cells list
    78837888            G2frame.GPXtree.SetItemPyData(item,data)                             
    78847889#patch
  • trunk/GSASIIphsGUI.py

    r3560 r3565  
    282282    #NB: commonNames & commonTrans defined in GSASIIdataGUI = G2gd
    283283    '''
    284     def __init__(self,parent,phases,Trans=np.eye(3),Uvec=np.zeros(3),Vvec=np.zeros(3),ifMag=False,newSpGrp='',BNSlatt=''):
     284    def __init__(self,parent,phase,Trans=np.eye(3),Uvec=np.zeros(3),Vvec=np.zeros(3),ifMag=False,BNSlatt=''):
    285285        wx.Dialog.__init__(self,parent,wx.ID_ANY,'Setup phase transformation',
    286286            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
    287287        self.panel = wx.Panel(self)         #just a dummy - gets destroyed in Draw!
    288         self.Phases = phases
    289         phase = self.Phases['parent']
    290288        self.Phase = copy.deepcopy(phase)   #will be a new phase!
    291289#        self.Super = phase['General']['Super']
     
    299297        self.oldSpGrp = phase['General']['SGData']['SpGrp']
    300298        self.oldSGdata = phase['General']['SGData']
    301         if newSpGrp:
    302             self.newSpGrp = newSpGrp
    303         else:
    304             self.newSpGrp = self.Phase['General']['SGData']['SpGrp']
     299        self.newSpGrp = self.Phase['General']['SGData']['SpGrp']
    305300        self.SGData = G2spc.SpcGroup(self.newSpGrp)[1]
    306301        self.oldCell = phase['General']['Cell'][1:8]
     
    407402            self.Mtrans = Obj.GetValue()
    408403           
    409         def OnNewBilbao(event):
    410             del self.oldSGdata['MAXMAGN']
    411             self.BNSlatt = ''
    412             self.Phases = self.Phases['parent']
    413             self.ifMag = False
    414             wx.CallAfter(self.Draw)
    415            
    416         def OnBilbao(event):
    417             import MAXMAGN
    418             oldkvec = self.kvec
    419             self.Mtrans = True
    420             SGNo = G2spc.SpaceGroupNumber(self.SGData['SpGrp'])
    421             if not SGNo+1:
    422                 wx.MessageBox('Nonstandard space group '+self.SGData['SpGrp']+' is not known by MAXMAGN',
    423                     caption='Bilbao MAXMAGN error',style=wx.ICON_EXCLAMATION)
    424                 return
    425             dlg = G2G.MultiFloatDialog(self,title='Propagation vector',prompts=[' kx',' ky',' kz'],
    426                     values=self.kvec,limits=[[0.,1.],[0.,1.],[0.,1.]],formats=['%4.1f','%4.1f','%4.1f'])
    427             if dlg.ShowModal() == wx.ID_OK:
    428                 self.kvec = dlg.GetValues()
    429                 if self.kvec != oldkvec or 'MAXMAGN' not in self.oldSGdata:
    430                     wx.BeginBusyCursor()
    431                     self.oldSGdata['MAXMAGN'] = MAXMAGN.MAXMAGN(SGNo,self.kvec)
    432                     wx.EndBusyCursor()
    433                     for result in self.oldSGdata['MAXMAGN']:
    434                         phase = {}
    435                         numbs = [eval(item+'.') for item in result[2].split()]
    436                         phase['Name'] = self.Phases['parent']['General']['Name']+' mag: '+result[0]
    437                         phase['Uvec'] = np.array(numbs[3::4])
    438                         phase['Trans'] = np.array([numbs[:3],numbs[4:7],numbs[8:11]])
    439                         SpGp = result[0].replace("'",'')
    440                         SpGrp = G2spc.StandardizeSpcName(SpGp)
    441                         phase['newSpGrp'] = SpGrp
    442                         phase['SGData'] = G2spc.SpcGroup(SpGrp)[1]
    443                         G2spc.GetSGSpin(phase['SGData'],result[0])
    444                         phase['BNSlatt'] = phase['SGData']['SGLatt']
    445                         if result[1]:
    446                             phase['BNSlatt'] += '_'+result[1]
    447                             BNSsym = G2spc.GetGenSym(phase['SGData'])[2]
    448                             phase['SGData']['BNSlattsym'] = [phase['BNSlatt'],BNSsym[phase['BNSlatt']]]
    449                             G2spc.ApplyBNSlatt(phase['SGData'],phase['SGData']['BNSlattsym'])
    450            
    451                         phase['SGData']['GenSym'],phase['SGData']['GenFlg'],BNSsym = G2spc.GetGenSym(phase['SGData'])
    452                         phase['SGData']['MagSpGrp'] = G2spc.MagSGSym(phase['SGData'])
    453                         OprNames,phase['SGData']['SpnFlp'] = G2spc.GenMagOps(phase['SGData'])   
    454                         self.Phases[result[0]] = phase
    455                     self.Bilbao = ''
    456             wx.CallAfter(self.Draw)
    457                    
    458         def OnBilbaoSG(event):
    459             Obj = event.GetEventObject()
    460             result = Obj.GetValue()
    461             self.Bilbao = result
    462             phase = self.Phases[result]
    463             self.Uvec = phase['Uvec']
    464             self.Trans = phase['Trans']
    465             self.newSpGrp = phase['newSpGrp']
    466             self.SGData = phase['SGData']
    467             self.BNSlatt = phase['BNSlatt']
    468             OprNames = G2spc.GenMagOps(self.SGData)[0]                   
    469                    
    470             msg = 'Space Group Information'
    471             text,table = G2spc.SGPrint(self.SGData,AddInv=True)
    472             text[0] = ' Magnetic Space Group: '+self.SGData['MagSpGrp']
    473             text[3] = ' The magnetic lattice point group is '+self.SGData['MagPtGp']
    474             G2G.SGMagSpinBox(self.panel,msg,text,table,self.SGData['SGCen'],OprNames,
    475                 self.SGData['SpnFlp'],False).Show()
    476            
    477             self.Phase['General']['SGData'] = self.SGData
    478 
    479             wx.CallAfter(self.Draw)
    480404
    481405        self.panel.Destroy()
     
    537461                Mtrans.Bind(wx.EVT_CHECKBOX,OnMtrans)
    538462                MagSizer.Add(Mtrans,0,WACV)
    539                 Bilbao = wx.Button(self.panel,label='Run Bilbao MAXMAGN')
    540                 Bilbao.Bind(wx.EVT_BUTTON,OnBilbao)
    541                 MagSizer.Add(Bilbao,0,WACV)
    542             else:
    543                 Bilbao = wx.Button(self.panel,label='Clear MAXMAGN')
    544                 Bilbao.Bind(wx.EVT_BUTTON,OnNewBilbao)
    545                 MagSizer.Add(Bilbao,0,WACV)
    546463            mainSizer.Add(MagSizer,0,WACV)
    547464        mainSizer.Add(wx.StaticText(self.panel,label=' Old lattice parameters:'),0,WACV)
     
    559476        sgSizer = wx.BoxSizer(wx.HORIZONTAL)
    560477        sgSizer.Add(wx.StaticText(self.panel,label=' Target space group: '),0,WACV)
    561         if self.oldSGdata.get('MAXMAGN',[]):
    562             Bilbao = []
    563             for result in self.oldSGdata['MAXMAGN']:
    564                 Bilbao.append(result[0])
    565             SGTxtB = wx.ComboBox(self.panel,choices=Bilbao,value=self.Bilbao,style=wx.CB_READONLY|wx.CB_DROPDOWN)
    566             SGTxtB.Bind(wx.EVT_COMBOBOX,OnBilbaoSG)
    567             sgSizer.Add(SGTxtB,0,WACV)
    568         else:
    569             SGTxt = wx.Button(self.panel,wx.ID_ANY,self.newSpGrp,size=(100,-1))
    570             SGTxt.Bind(wx.EVT_BUTTON,OnSpaceGroup)
    571             sgSizer.Add(SGTxt,0,WACV)
     478        SGTxt = wx.Button(self.panel,wx.ID_ANY,self.newSpGrp,size=(100,-1))
     479        SGTxt.Bind(wx.EVT_BUTTON,OnSpaceGroup)
     480        sgSizer.Add(SGTxt,0,WACV)
    572481        mainSizer.Add(sgSizer,0,WACV)
    573482        if 'magnetic' not in self.Phase['General']['Type']:
    574             if self.ifMag and not self.oldSGdata.get('MAXMAGN',[]):
     483            if self.ifMag:
    575484                GenSym,GenFlg,BNSsym = G2spc.GetGenSym(self.SGData)
    576485                BNSizer = wx.BoxSizer(wx.HORIZONTAL)
     
    623532        if self.Mtrans:
    624533            self.Phase['General']['Cell'][1:] = G2lat.TransformCell(self.oldCell[:6],self.Trans.T)           
    625             return self.Phase,self.Trans.T,self.Uvec,self.Vvec,self.ifMag,self.ifConstr,self.Common,self.Phases
     534            return self.Phase,self.Trans.T,self.Uvec,self.Vvec,self.ifMag,self.ifConstr,self.Common
    626535        else:
    627536            self.Phase['General']['Cell'][1:] = G2lat.TransformCell(self.oldCell[:6],self.Trans)           
    628             return self.Phase,self.Trans,self.Uvec,self.Vvec,self.ifMag,self.ifConstr,self.Common,self.Phases
     537            return self.Phase,self.Trans,self.Uvec,self.Vvec,self.ifMag,self.ifConstr,self.Common
    629538
    630539    def OnOk(self,event):
     
    642551    '''Get user selected magnetic atoms after cell transformation
    643552    '''
    644     def __init__(self,parent,Atoms,atCodes):
     553    def __init__(self,parent,Atoms,atCodes,atMxyz):
    645554        wx.Dialog.__init__(self,parent,wx.ID_ANY,'Magnetic atom selection',
    646555            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
     
    648557        self.Atoms = Atoms
    649558        self.atCodes = atCodes
     559        self.atMxyz = atMxyz
    650560        self.Use = len(self.Atoms)*[True,]
    651561        self.Draw()
     
    662572        self.panel = wx.Panel(self)
    663573        Indx = {}
     574        Mstr = ['Mx','My','Mz']
    664575        mainSizer = wx.BoxSizer(wx.VERTICAL)
    665576       
    666         mainSizer.Add(wx.StaticText(self.panel,label=' Name, x, y, z:'),0,WACV)
     577        mainSizer.Add(wx.StaticText(self.panel,label='        Name, x, y, z, allowed moments:'),0,WACV)
    667578        atmSizer = wx.FlexGridSizer(0,2,5,5)
    668         for iuse,[use,atom] in enumerate(zip(self.Use,self.Atoms)):
     579        for iuse,[use,atom,mxyz] in enumerate(zip(self.Use,self.Atoms,self.atMxyz)):
     580            mstr = ['___','___','___']
     581            for i,mx in enumerate(mxyz):
     582                if mx:
     583                    mstr[i] = Mstr[i]
    669584            useChk = wx.CheckBox(self.panel,label='Use?')
    670585            Indx[useChk.GetId()] = iuse
     
    672587            useChk.Bind(wx.EVT_CHECKBOX, OnUseChk)
    673588            atmSizer.Add(useChk,0,WACV)
    674             text = ' %s %10.5f %10.5f %10.5f'%(atom[0],atom[3],atom[4],atom[5])
     589            text = '  %s %10.5f %10.5f %10.5f %4s %4s %4s   '%(atom[0],atom[3],atom[4],atom[5],mstr[0],mstr[1],mstr[2])
    675590            atmSizer.Add(wx.StaticText(self.panel,label=text),0,WACV)
    676591        mainSizer.Add(atmSizer)
     
    24482363        Vvec = np.zeros(3)
    24492364        ifMag = False
    2450         newSpGrp = ''
    24512365        BNSlatt = ''
    2452         if not G2frame.MagPhases:
    2453             G2frame.MagPhases = {'parent':data}
    2454         else:
    2455             G2frame.MagPhases['parent'] = data
    24562366        while True:
    2457             dlg = TransformDialog(G2frame,G2frame.MagPhases,Trans,Uvec,Vvec,ifMag,newSpGrp,BNSlatt)
     2367            dlg = TransformDialog(G2frame,data,Trans,Uvec,Vvec,ifMag,BNSlatt)
    24582368            try:
    24592369                if dlg.ShowModal() == wx.ID_OK:
    2460                     newPhase,Trans,Uvec,Vvec,ifMag,ifConstr,Common,MagPhases = dlg.GetSelection()
    2461                     G2frame.MagPhases = MagPhases
    2462                     newSpGrp = newPhase['General']['SGData']['SpGrp']
     2370                    newPhase,Trans,Uvec,Vvec,ifMag,ifConstr,Common = dlg.GetSelection()
    24632371                    if ifMag:
    24642372                        BNSlatt = newPhase['General']['SGData']['BNSlattsym'][0]
     
    24832391                newPhase,atCodes = G2lat.TransformPhase(data,newPhase,Trans,Uvec,Vvec,ifMag)
    24842392                detTrans = np.abs(nl.det(Trans))
    2485        
    2486                 newPhase['ParentId'] = data['ranId']
    24872393                generalData = newPhase['General']
    24882394                SGData = generalData['SGData']
     
    24902396                Atoms = newPhase['Atoms']
    24912397                if ifMag:
    2492                     dlg = UseMagAtomDialog(G2frame,Atoms,atCodes)
     2398                    atMxyz = []
     2399                    SGData['GenSym'],SGData['GenFlg'],BNSsym = G2spc.GetGenSym(SGData)
     2400                    SGData['OprNames'],SGData['SpnFlp'] = G2spc.GenMagOps(SGData)
     2401                    SGData['MagSpGrp'] = G2spc.MagSGSym(SGData)
     2402                    for atom in Atoms:
     2403                        SytSym,Mul,Nop,dupDir = G2spc.SytSym(atom[3:6],SGData)
     2404                        CSI = G2spc.GetCSpqinel(SGData['SpnFlp'],dupDir)
     2405                        atMxyz.append(CSI[0])
     2406                        print (atom[3:6],CSI)
     2407                    dlg = UseMagAtomDialog(G2frame,Atoms,atCodes,atMxyz)
    24932408                    try:
    24942409                        if dlg.ShowModal() == wx.ID_OK:
    24952410                            newPhase['Atoms'],atCodes = dlg.GetSelection()
    2496                             SGData['GenSym'],SGData['GenFlg'],BNSsym = G2spc.GetGenSym(SGData)
    2497                             SGData['OprNames'],SGData['SpnFlp'] = G2spc.GenMagOps(SGData)
    2498                             SGData['MagSpGrp'] = G2spc.MagSGSym(SGData)
    24992411                            generalData['Lande g'] = len(generalData['AtomTypes'])*[2.,]
    25002412                            break
     
    25192431        if ifConstr:
    25202432            G2cnstG.TransConstraints(G2frame,data,newPhase,Trans,Vvec,atCodes)     #data is old phase
     2433        G2frame.GPXtree.SelectItem(sub)
     2434               
     2435    def OnUseBilbao(event):
     2436        PatternName = data['magPhases']
     2437        PatternId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,PatternName)
     2438        UnitCellsId = G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List')
     2439        magData = G2frame.GPXtree.GetItemPyData(UnitCellsId)[5]
     2440        magKeep = []
     2441        magchoices = []
     2442        for magdata in magData:
     2443            if magdata['Keep']:
     2444                magKeep.append(magdata)
     2445                magchoices.append(magdata['Name'])
     2446        if not len(magKeep):
     2447            G2frame.ErrorDialog('Magnetic phase selection error','No magnetic phases found; be sure to "Keep" some')
     2448            return
     2449        dlg = wx.SingleChoiceDialog(G2frame,'Select magnetic space group','Make new magnetic phase',magchoices)
     2450        if dlg.ShowModal() == wx.ID_OK:
     2451            vvec = np.zeros(3)
     2452            magchoice = magKeep[dlg.GetSelection()]
     2453            phaseName = magchoice['Name']+ 'mag'
     2454            newPhase = copy.deepcopy(data)
     2455            del newPhase['magPhases']
     2456            newPhase,atCodes = G2lat.TransformPhase(data,newPhase,magchoice['Trans'],magchoice['Uvec'],vvec,True)
     2457            detTrans = np.abs(nl.det(magchoice['Trans']))
     2458            generalData = newPhase['General']
     2459            generalData['SGData'] = copy.deepcopy(magchoice['SGData'])
     2460            SGData = generalData['SGData']
     2461            Atoms = newPhase['Atoms']
     2462            atMxyz = []
     2463            for atom in Atoms:
     2464                SytSym,Mul,Nop,dupDir = G2spc.SytSym(atom[3:6],SGData)
     2465                CSI = G2spc.GetCSpqinel(SGData['SpnFlp'],dupDir)
     2466                atMxyz.append(CSI[0])
     2467            dlg = UseMagAtomDialog(G2frame,Atoms,atCodes,atMxyz)
     2468            try:
     2469                if dlg.ShowModal() == wx.ID_OK:
     2470                    newPhase['Atoms'],atCodes = dlg.GetSelection()
     2471                    generalData['Lande g'] = len(generalData['AtomTypes'])*[2.,]
     2472                else:
     2473                    return
     2474            finally:
     2475                dlg.Destroy()
     2476        NShkl = len(G2spc.MustrainNames(SGData))
     2477        NDij = len(G2spc.HStrainNames(SGData))
     2478        UseList = newPhase['Histograms']
     2479        for hist in UseList:
     2480            UseList[hist]['Scale'] /= detTrans      #scale by 1/volume ratio
     2481            UseList[hist]['Mustrain'][4:6] = [NShkl*[0.01,],NShkl*[False,]]
     2482            UseList[hist]['HStrain'] = [NDij*[0.0,],NDij*[False,]]
     2483        newPhase['General']['Map'] = mapDefault.copy()
     2484        sub = G2frame.GPXtree.AppendItem(parent=
     2485            G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
     2486        G2frame.GPXtree.SetItemPyData(sub,newPhase)
     2487        newPhase['Drawing'] = []
     2488        G2cnstG.TransConstraints(G2frame,data,newPhase,magchoice['Trans'],vvec,atCodes)     #data is old phase
    25212489        G2frame.GPXtree.SelectItem(sub)
    25222490       
     
    91819149        G2frame.Bind(wx.EVT_MENU, OnRunMultiMCSA, id=G2G.wxID_MULTIMCSA)
    91829150        G2frame.Bind(wx.EVT_MENU, OnTransform, id=G2G.wxID_TRANSFORMSTRUCTURE)
     9151        G2frame.Bind(wx.EVT_MENU, OnUseBilbao, id=G2G.wxID_USEBILBAOMAG)
    91839152        G2frame.Bind(wx.EVT_MENU, OnValidProtein, id=G2G.wxID_VALIDPROTEIN)
    91849153        # Data
     
    93759344    G2frame.dataWindow.AtomCompute.Enable(G2G.wxID_ISODISP,'ISODISTORT' in data)
    93769345    G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_VALIDPROTEIN,'macro' in data['General']['Type'])
     9346    G2frame.dataWindow.GeneralCalc.Enable(G2G.wxID_USEBILBAOMAG,'magPhases' in data)
    93779347    G2frame.phaseDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
    93789348    FillMenus()
  • trunk/GSASIIplot.py

    r3561 r3565  
    18911891            else:
    18921892                pickIdText = '?' # unexpected
    1893             if pickIdText in ['Index Peak List',
    1894                               'Unit Cells List','Reflection Lists'] and len(G2frame.HKL):
     1893            if pickIdText in ['Index Peak List','Unit Cells List','Reflection Lists'] and len(G2frame.HKL):
    18951894                found = []
    18961895                indx = -1
  • trunk/GSASIIpwd.py

    r3561 r3565  
    10371037    :param A: lattice parameter terms A1-A6
    10381038    :param Inst: instrument parameter info
    1039     :returns: HKLs: list hkl, etc for allowed reflections
     1039    :returns: HKLs: np.array hkl, etc for allowed reflections
    10401040
    10411041    '''
     
    10511051            else:
    10521052                HKLs.append([h,k,l,d,G2lat.Dsp2pos(Inst,d),-1])
    1053     return HKLs
     1053    return np.array(HKLs)
    10541054
    10551055def getHKLMpeak(dmin,Inst,SGData,SSGData,Vec,maxH,A):
  • trunk/GSASIIpwdGUI.py

    r3562 r3565  
    26732673            if len(Unit) == 4:  #patch
    26742674                Unit.append({})
    2675             controls,bravais,cellist,dmin,ssopt = Unit
     2675            if len(Unit) == 5:  #patch
     2676                Unit.append({})
     2677            controls,bravais,cellist,dmin,ssopt,magcells = Unit
    26762678            if 'T' in Inst['Type'][0]:   #TOF - use other limit!
    26772679                dmin = G2lat.Pos2dsp(Inst,Limits[1][0])
     
    29772979        PatternId = G2frame.PatternId
    29782980        peaks = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Index Peak List'))
    2979         controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
     2981        controls,bravais,cells,dminx,ssopt,magcells = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
    29802982        cell = controls[6:12]
    29812983        A = G2lat.cell2A(cell)
     
    30413043
    30423044    def LoadUnitCell(event):
    3043         controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(UnitCellsId)
     3045        controls,bravais,cells,dminx,ssopt,magcells = G2frame.GPXtree.GetItemPyData(UnitCellsId)
    30443046        pId = G2gd.GetGPXtreeItemId(G2frame,G2frame.root, 'Phases')
    30453047        if not pId: return
     
    30523054        if pNum is None: return
    30533055        Phase = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,pId,Phases[pNum]))
     3056        Phase['magPhases'] = G2frame.GPXtree.GetItemText(G2frame.PatternId)    #use as reference for recovering possible mag phases
    30543057        Cell = Phase['General']['Cell']
    30553058        SGData = Phase['General']['SGData']
     
    30593062        controls[6:13] = Cell[1:8]
    30603063        controls[13] = SGData['SpGrp']
     3064        if 'N' in Inst['Type'][0]:
     3065            G2frame.dataWindow.RunSubGroupsMag.Enable(True)
    30613066        G2frame.dataWindow.RefineCell.Enable(True)
    30623067        OnHklShow(None)
     
    31083113            return       
    31093114        print (' Refine cell')
    3110         controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
     3115        controls,bravais,cells,dminx,ssopt,magcells = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
    31113116        cell = controls[6:12]
    31123117        A = G2lat.cell2A(cell)
     
    31383143                peaks = [G2indx.IndexPeaks(peaks[0],G2frame.HKL)[1],peaks[1]]   #put peak fit esds back in peaks
    31393144                Lhkl,M20,X20,Aref,Zero = G2indx.refinePeaksT(peaks[0],difC,ibrav,A,controls[1],controls[0])           
    3140         G2frame.HKL = np.array(G2frame.HKL)
    31413145        controls[1] = Zero
    31423146        controls[6:12] = G2lat.A2cell(Aref)
     
    31513155        else:
    31523156            G2frame.HKL = G2pwd.getHKLpeak(dmin,SGData,A,Inst)
    3153         data = [controls,bravais,cells,dmin,ssopt]
     3157        G2frame.HKL = np.array(G2frame.HKL)
     3158        data = [controls,bravais,cells,dmin,ssopt,magcells]
    31543159        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
    31553160        print (" %s%10.3f" % ('refinement M20 = ',M20))
     
    31743179        keepcells = []
    31753180        try:
    3176             controls,bravais,cells,dminx,ssopt = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
     3181            controls,bravais,cells,dminx,ssopt,magcells = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'))
    31773182            for cell in cells:
    31783183                if cell[11]:
     
    32113216        if OK:
    32123217            cells[0][10] = True         #select best M20
    3213             data = [controls,bravais,cells,dmin,ssopt]
     3218            data = [controls,bravais,cells,dmin,ssopt,magcells]
    32143219            G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,PatternId, 'Unit Cells List'),data)
    32153220            bestCell = cells[0]
     
    32593264                    UnitCellsTable.SetValue(r,c,True)
    32603265                gridDisplay.ForceRefresh()
     3266            G2frame.GPXtree.SetItemPyData(UnitCellsId,data)
     3267       
     3268    def RefreshMagCellsGrid(event):
     3269        data = G2frame.GPXtree.GetItemPyData(UnitCellsId)
     3270        magcells = data[5]
     3271        r,c =  event.GetRow(),event.GetCol()
     3272        if magcells:
     3273            if c == 1:
     3274                for i in range(len(magcells)):
     3275                    magcells[i]['Use'] = False
     3276                    MagCellsTable.SetValue(i,c,False)
     3277                MagCellsTable.SetValue(r,c,True)
     3278                magDisplay.ForceRefresh()
     3279                magcells[r]['Use'] = True
     3280                SGData = magcells[r]['SGData']
     3281                A = G2lat.cell2A(magcells[r]['Cell'][:6]) 
     3282                G2frame.HKL = G2pwd.getHKLpeak(1.0,SGData,A,Inst)
     3283                G2plt.PlotPatterns(G2frame)
     3284            elif c == 2:
     3285                if MagCellsTable.GetValue(r,c):
     3286                    MagCellsTable.SetValue(r,c,False)
     3287                    magcells[r]['Keep'] = False
     3288                else:
     3289                    magcells[r]['Keep'] = True
     3290                    MagCellsTable.SetValue(r,c,True)
     3291                magDisplay.ForceRefresh()
     3292            data[5] = magcells
    32613293            G2frame.GPXtree.SetItemPyData(UnitCellsId,data)
    32623294       
     
    33473379        ifMag = False
    33483380        Type = 'nuclear'
    3349         newSpGrp = ''
    33503381        BNSlatt = ''
    33513382        E,SGData = G2spc.SpcGroup(controls[13])
    33523383        phase = {'General':{'Name':'','Type':Type,'Cell':['',]+controls[6:13],'SGData':SGData}}
    3353         if not G2frame.MagPhases:
    3354             G2frame.MagPhases = {'parent':phase}
    3355         else:
    3356             G2frame.MagPhases['parent'] = phase         #do I want to do this or reverse??
    3357         dlg = G2phsG.TransformDialog(G2frame,G2frame.MagPhases,Trans,Uvec,Vvec,ifMag,newSpGrp,BNSlatt)
     3384        dlg = G2phsG.TransformDialog(G2frame,phase,Trans,Uvec,Vvec,ifMag,BNSlatt)
    33583385        try:
    33593386            if dlg.ShowModal() == wx.ID_OK:
    3360                 newPhase,Trans,Uvec,Vvec,ifMag,ifConstr,Common,MagPhases = dlg.GetSelection()
    3361                 G2frame.MagPhases = MagPhases
     3387                newPhase,Trans,Uvec,Vvec,ifMag,ifConstr,Common = dlg.GetSelection()
    33623388                sgData = newPhase['General']['SGData']
    33633389                controls[5] = sgData['SGLatt']+sgData['SGLaue']
     
    33723398        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
    33733399       
     3400    def OnRunSubsMag(event):
     3401        import kSUBGROUPSMAG as kMAG
     3402        controls,bravais,cells,dminx,ssopt,magcells = G2frame.GPXtree.GetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'))
     3403        E,SGData = G2spc.SpcGroup(controls[13])
     3404        kvec = [0.,0.,0.]
     3405        dlg = G2G.MultiFloatDialog(G2frame,title='k-SUBGROUPSMAG options',prompts=[' kx',' ky',' kz',' Use whole star',' Landau transition',' Give intermediate cells'],
     3406                values=kvec+[False,False,False],limits=[[0.,1.],[0.,1.],[0.,1.],[True,False],[True,False],[True,False]],formats=['%4.1f','%4.1f','%4.1f','bool','bool','bool'])
     3407        if dlg.ShowModal() == wx.ID_OK:
     3408            magcells = []
     3409            newVals = dlg.GetValues()
     3410            kvec = newVals[:3]
     3411            star = newVals[3]
     3412            Landau = newVals[4]
     3413            intermed = newVals[5]
     3414            wx.BeginBusyCursor()
     3415            MAXMAGN = kMAG.GetNonStdSubgroupsmag(SGData,kvec,star,Landau,intermed)
     3416            wx.EndBusyCursor()
     3417            for result in MAXMAGN:
     3418                if result[0].strip().endswith("1'"):    #skip gray groups
     3419                    continue
     3420                phase = {}
     3421                numbs = [eval(item+'.') for item in result[2].split()]
     3422                phase['Name'] = result[0].strip()
     3423                phase['Uvec'] = np.array(numbs[3::4])
     3424                phase['Trans'] = np.array([numbs[:3],numbs[4:7],numbs[8:11]])
     3425                phase['Cell'] = G2lat.TransformCell(controls[6:12],phase['Trans'].T)   
     3426                phase['Keep'] = False
     3427                phase['Use'] = False
     3428                SpGp = result[0].replace("'",'')
     3429                SpGrp = G2spc.StandardizeSpcName(SpGp)
     3430                phase['SGData'] = G2spc.SpcGroup(SpGrp)[1]
     3431                G2spc.GetSGSpin(phase['SGData'],result[0])
     3432                phase['BNSlatt'] = phase['SGData']['SGLatt']
     3433                if result[1]:
     3434                    phase['BNSlatt'] += '_'+result[1]
     3435                    BNSsym = G2spc.GetGenSym(phase['SGData'])[2]
     3436                    phase['SGData']['BNSlattsym'] = [phase['BNSlatt'],BNSsym[phase['BNSlatt']]]
     3437                    G2spc.ApplyBNSlatt(phase['SGData'],phase['SGData']['BNSlattsym'])   
     3438                phase['SGData']['GenSym'],phase['SGData']['GenFlg'],BNSsym = G2spc.GetGenSym(phase['SGData'])
     3439                phase['SGData']['MagSpGrp'] = G2spc.MagSGSym(phase['SGData'])
     3440                OprNames,SpnFlp = G2spc.GenMagOps(phase['SGData'])
     3441                phase['SGData']['SpnFlp'] = SpnFlp
     3442                magcells.append(phase)
     3443            magcells[0]['Use'] = True
     3444            SGData = magcells[0]['SGData']
     3445            A = G2lat.cell2A(magcells[0]['Cell'][:6]) 
     3446            G2frame.HKL = G2pwd.getHKLpeak(1.0,SGData,A,Inst)
     3447            G2plt.PlotPatterns(G2frame)
     3448        data = [controls,bravais,cells,dmin,ssopt,magcells]
     3449        G2frame.GPXtree.SetItemPyData(G2gd.GetGPXtreeItemId(G2frame,G2frame.PatternId, 'Unit Cells List'),data)
     3450        wx.CallAfter(UpdateUnitCellsGrid,G2frame,data)
     3451       
    33743452    G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.IndexMenu)
    33753453    G2frame.Bind(wx.EVT_MENU, OnIndexPeaks, id=G2G.wxID_INDEXPEAKS)
     3454    G2frame.Bind(wx.EVT_MENU, OnRunSubsMag, id=G2G.wxID_RUNSUBMAG)
    33763455    G2frame.Bind(wx.EVT_MENU, CopyUnitCell, id=G2G.wxID_COPYCELL)
    33773456    G2frame.Bind(wx.EVT_MENU, LoadUnitCell, id=G2G.wxID_LOADCELL)
     
    33823461    G2frame.Bind(wx.EVT_MENU, OnExportCells, id=G2G.wxID_EXPORTCELLS)
    33833462       
    3384     controls,bravais,cells,dminx,ssopt = data
     3463    if len(data) < 6:
     3464        data.append([])
     3465    controls,bravais,cells,dminx,ssopt,magcells = data
    33853466    if len(controls) < 13:              #add cell volume if missing
    33863467        controls.append(G2lat.calc_V(G2lat.cell2A(controls[6:12])))
     
    34163497        G2frame.dataWindow.MakeNewPhase.Enable(True)
    34173498        G2frame.dataWindow.ExportCells.Enable(True)
     3499#    G2frame.dataWindow.RunSubGroupsMag.Enable(False)
    34183500    G2frame.dataWindow.ClearData()
    34193501    mainSizer = G2frame.dataWindow.GetSizer()
     
    36393721                    gridDisplay.SetReadOnly(r,c,isReadOnly=True)
    36403722        mainSizer.Add(gridDisplay,0,WACV)
     3723    if magcells and 'N' in Inst['Type'][0]:
     3724        if 'N' in Inst['Type'][0]:
     3725            G2frame.dataWindow.RunSubGroupsMag.Enable(True)
     3726        mainSizer.Add(wx.StaticText(parent=G2frame.dataWindow,label='\n Magnetic cells from Bilbao k-SUBGROUPSMAG:'),0,WACV)
     3727        rowLabels = []
     3728        colLabels = ['Space Gp.','Try','Keep','a','b','c','alpha','beta','gamma','Volume']
     3729        Types = [wg.GRID_VALUE_STRING,wg.GRID_VALUE_BOOL,wg.GRID_VALUE_BOOL,]+3*[wg.GRID_VALUE_FLOAT+':10,5',]+ \
     3730            3*[wg.GRID_VALUE_FLOAT+':10,3',]+[wg.GRID_VALUE_FLOAT+':10,2']
     3731        table = []
     3732        for phase in magcells:
     3733            rowLabels.append('')
     3734            cell  = list(phase['Cell'])
     3735            row = [phase['Name'],phase['Use'],phase['Keep'],]+cell
     3736            table.append(row)
     3737        MagCellsTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
     3738        magDisplay = G2G.GSGrid(G2frame.dataWindow)
     3739        magDisplay.SetTable(MagCellsTable, True)
     3740        magDisplay.Bind(wg.EVT_GRID_CELL_LEFT_CLICK,RefreshMagCellsGrid)
     3741        magDisplay.SetRowLabelSize(0)
     3742        magDisplay.AutoSizeColumns(False)
     3743        for r in range(magDisplay.GetNumberRows()):
     3744            for c in range(magDisplay.GetNumberCols()):
     3745                if c in [1,2]:
     3746                    magDisplay.SetReadOnly(r,c,isReadOnly=False)
     3747                else:
     3748                    magDisplay.SetReadOnly(r,c,isReadOnly=True)
     3749        mainSizer.Add(magDisplay,0,WACV)
     3750       
    36413751    G2frame.dataWindow.SetDataSize()
    36423752   
  • trunk/GSASIIspc.py

    r3562 r3565  
    535535
    536536def TextGen(SGData,reverse=False):
     537    GenSym,GenFlg,BNSsym = GetGenSym(SGData)
     538    SGData['GenSym'] = GenSym
     539    SGData['GenFlg'] = GenFlg
    537540    text,table = SGPrint(SGData)
    538541    GenText = []
     542    OprNames = GetOprNames(SGData)
    539543    OpText = TextOps(text,table,reverse)
    540     for gid in SGData['GenFlg']:
     544    for name in SGData['GenSym']:
     545        gid = OprNames.index(name.replace(' ',''))
    541546        GenText.append(OpText[gid])
     547    if len(SGData['SGCen']) > 1:
     548        GenText.append(OpText[-1])
    542549    return GenText
     550
     551def GetOprNames(SGData):
     552    OprNames = [GetOprPtrName(str(irtx)) for irtx in PackRot(SGData['SGOps'])]
     553    if SGData['SGInv']:
     554        OprNames += [GetOprPtrName(str(-irtx)) for irtx in PackRot(SGData['SGOps'])]
     555    return OprNames
    543556   
    544557def MT2text(Opr,reverse=False):
Note: See TracChangeset for help on using the changeset viewer.