Changeset 2473


Ignore:
Timestamp:
Sep 20, 2016 1:58:10 PM (5 years ago)
Author:
vondreele
Message:

work on magnetic structures - import from EXP, plotting, LS refine I/O, mag. form factors, etc.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIElem.py

    r1589 r2473  
    5555    for El in atomTypes:
    5656        FFs = GetFormFactorCoeff(getElSym(El))
     57        for item in FFs:
     58            if item['Symbol'] == El.upper():
     59                FFtable[El] = item
     60    return FFtable
     61   
     62def GetMFtable(atomTypes):
     63    ''' returns a dictionary of magnetic form factor data for atom types found in atomTypes
     64
     65    :param list atomTypes: list of atom types
     66    :return: FFtable, dictionary of form factor data; key is atom type
     67
     68    '''
     69    FFtable = {}
     70    for El in atomTypes:
     71        FFs = GetMagFormFacCoeff(getElSym(El))
    5772        for item in FFs:
    5873            if item['Symbol'] == El.upper():
     
    266281   
    267282def GetMagFormFacCoeff(El):
    268     """Read magnetic form factor data from atomdata.asc file
     283    """Read magnetic form factor data from atmdata.py
    269284
    270285    :param El: 2 character element symbol
     
    283298   
    284299    """
     300    Els = El.capitalize().strip()
    285301    MagFormFactors = []
    286     mags = [ky for ky in atmdata.MagFF.keys() if El == getElSym(ky)]
     302    mags = [ky for ky in atmdata.MagFF.keys() if Els == getElSym(ky)]
    287303    for mag in mags:
    288304        magData = {}
    289305        data = atmdata.MagFF[mag]
    290         magData['Symbol'] = mag
    291         magData['Z'] = atmdata.XrayFF[getElSym(mags)]['Z']
     306        magData['Symbol'] = mag.upper()
     307        magData['Z'] = atmdata.XrayFF[getElSym(mag)]['Z']
    292308        magData['mfa'] = [data['M'][i] for i in [0,2,4,6]]
    293         magdata['mfb'] = [data['M'][i] for i in [1,3,5,7]]
    294         magdata['mfc'] = data['M'][8]
     309        magData['mfb'] = [data['M'][i] for i in [1,3,5,7]]
     310        magData['mfc'] = data['M'][8]
    295311        magData['nfa'] = [data['N'][i] for i in [0,2,4,6]]
    296         magdata['nfb'] = [data['N'][i] for i in [1,3,5,7]]
    297         magdata['nfc'] = data['N'][8]
    298         magdata['g-fac'] = data['N'][9]
    299         MagFormFactors.append(magdata)
     312        magData['nfb'] = [data['N'][i] for i in [1,3,5,7]]
     313        magData['nfc'] = data['N'][8]
     314        MagFormFactors.append(magData)
    300315    return MagFormFactors
    301316
     
    311326    t = -fb[:,np.newaxis]*SQ
    312327    return np.sum(fa[:,np.newaxis]*np.exp(t)[:],axis=0)+El['fc']
     328       
     329def MagScatFac(El, SQ,gfac):
     330    """compute value of form factor
     331
     332    :param El: element dictionary defined in GetFormFactorCoeff
     333    :param SQ: (sin-theta/lambda)**2
     334    :param gfac: Lande g factor (normally = 2.0)
     335    :return: real part of form factor
     336    """
     337    mfa = np.array(El['mfa'])
     338    mfb = np.array(El['mfb'])
     339    nfa = np.array(El['nfa'])
     340    nfb = np.array(El['nfb'])
     341    mt = -mfb[:,np.newaxis]*SQ
     342    nt = -nfb[:,np.newaxis]*SQ
     343    MMF = np.sum(mfa[:,np.newaxis]*np.exp(mt)[:],axis=0)+El['mfc']
     344    NMF = np.sum(nfa[:,np.newaxis]*np.exp(nt)[:],axis=0)+El['nfc']
     345    return MMF+(2.0/gfac-1.0)*NMF
    313346       
    314347def BlenResCW(Els,BLtables,wave):
  • trunk/GSASIIconstrGUI.py

    r2434 r2473  
    250250    for item in phaseList:
    251251        Split = item.split(':')
    252         if Split[2][:2] in ['AU','Af','dA']:
     252        if Split[2][:2] in ['AU','Af','dA','AM']:
    253253            Id = int(Split[0])
    254254            phaseAtNames[item] = AtomDict[Id][int(Split[3])][0]
     
    304304        elif 'AU' in name:
    305305            namelist = ['AUiso','AU11','AU22','AU33','AU12','AU13','AU23']
     306        elif 'AM' in name:
     307            namelist = ['AMx','AMy','AMz']
    306308        elif 'Tm' in name:
    307309            namelist = ['Tmin','Tmax']
  • trunk/GSASIIlattice.py

    r2470 r2473  
    231231def TransformPhase(oldPhase,newPhase,Trans,Vec):
    232232    '''Transform atoms from oldPhase to newPhase by Trans & Vec
     233    NB: doesnt transform moments correctly - TBD
    233234   
    234235    :param oldPhase: dict G2 phase info for old phase
  • trunk/GSASIIobj.py

    r2433 r2473  
    12881288        'Afrac': 'Atomic occupancy parameter',
    12891289        'Amul': 'Atomic site multiplicity value',
     1290        'AM([xyz])$' : 'Atomic magnetic moment parameter, \\1',
    12901291        # Hist & Phase (HAP) vars (p:h:<var>)
    12911292        'Back': 'Background term',
  • trunk/GSASIIphsGUI.py

    r2471 r2473  
    5050import GSASIIobj as G2obj
    5151import GSASIIctrls as G2G
     52import atmdata
    5253import numpy as np
    5354import numpy.linalg as nl
     
    245246        generalData['AtomMass'] = []
    246247        generalData['Color'] = []
     248        if generalData['Type'] == 'magnetic' and not 'Lande g' in generalData:
     249            generalData['MagDmin'] = 1.0
     250            generalData['Lande g'] = []
    247251        generalData['Mydir'] = G2frame.dirname
    248252        badList = {}
     
    250254            atom[ct] = atom[ct].lower().capitalize()              #force to standard form
    251255            if generalData['AtomTypes'].count(atom[ct]):
    252                 generalData['NoAtoms'][atom[ct]] += atom[cs-1]*float(atom[cs+1])
     256                generalData['NoAtoms'][atom[ct]] += atom[cx+3]*float(atom[cs+1])
    253257            elif atom[ct] != 'UNK':
    254258                Info = G2elem.GetAtomInfo(atom[ct])
     
    277281                        generalData['Isotope'][atom[ct]] = isotope
    278282                    generalData['AtomMass'].append(Info['Mass'])
    279                 generalData['NoAtoms'][atom[ct]] = atom[cs-1]*float(atom[cs+1])
     283                generalData['NoAtoms'][atom[ct]] = atom[cx+3]*float(atom[cs+1])
    280284                generalData['Color'].append(Info['Color'])
     285                if generalData['Type'] == 'magnetic':
     286                    generalData['MagDmin'] = generalData.get('MagDmin',1.0)
     287                    if atom[ct] in atmdata.MagFF:
     288                        generalData['Lande g'].append(2.0)
     289                    else:
     290                        generalData['Lande g'].append(None)
    281291        if badList:
    282292            msg = 'Warning: element symbol(s) not found:'
     
    651661                if denSizer[2]:
    652662                    denSizer[2].SetValue('%.3f'%(mattCoeff))
     663                   
     664            def OnGfacVal(event):
     665                Obj = event.GetEventObject()
     666                ig = Indx[Obj.GetId()]
     667                try:
     668                    val = float(Obj.GetValue())
     669                    if val < 1. or val > 2.0:
     670                        raise ValueError
     671                except ValueError:
     672                    val = generalData['Lande g'][ig]
     673                generalData['Lande g'][ig] = val
     674                Obj.SetValue('%.2f'%(val))
    653675               
    654676            elemSizer = wx.FlexGridSizer(0,len(generalData['AtomTypes'])+1,1,1)
     
    697719                colorTxt.SetBackgroundColour(wx.Colour(R,G,B))
    698720                elemSizer.Add(colorTxt,0,WACV)
    699            
     721            if generalData['Type'] == 'magnetic':
     722                elemSizer.Add(wx.StaticText(General,label=' Lande g factor: '),0,WACV)
     723                for ig,gfac in enumerate(generalData['Lande g']):
     724                    if gfac == None:
     725                        elemSizer.Add((5,0),)
     726                    else:
     727                        gfacTxt = wx.TextCtrl(General,value='%.2f'%(gfac),style=wx.TE_PROCESS_ENTER)
     728                        Indx[gfacTxt.GetId()] = ig
     729                        gfacTxt.Bind(wx.EVT_TEXT_ENTER,OnGfacVal)       
     730                        gfacTxt.Bind(wx.EVT_KILL_FOCUS,OnGfacVal)
     731                        elemSizer.Add(gfacTxt,0,WACV)
    700732            return elemSizer
    701733       
     
    733765                text,table = G2spc.SGPrint(SGData,AddInv=True)
    734766                text[0] = ' Magnetic Space Group: '+SGData['MagSpGrp']
     767                text[3] = ' The magnetic lattice point group is '+SGData['MagPtGp']
    735768                G2gd.SGMagSpinBox(General,msg,text,table,OprNames,SpnFlp).Show()
     769               
     770            def OnDminVal(event):
     771                event.Skip()
     772                try:
     773                    val = float(dminVal.GetValue())
     774                    if val > 0.7:
     775                        generalData['MagDmin'] = val
     776                except ValueError:
     777                    pass
     778                dminVal.SetValue("%.4f"%(generalData['MagDmin']))
    736779               
    737780            SGData = generalData['SGData']           
     
    740783            magSizer = wx.BoxSizer(wx.VERTICAL)
    741784            magSizer.Add(wx.StaticText(General,label=' Magnetic spin operator selection:'),0,WACV)
    742             magSizer.Add(wx.StaticText(General,label='NB: UNDER CONSTRUCTION - LS NOT AVAILABLE'),0,WACV)
     785            magSizer.Add(wx.StaticText(General,label='  NB: UNDER CONSTRUCTION - LS NOT AVAILABLE'),0,WACV)
    743786            if not len(GenSym):
    744787                magSizer.Add(wx.StaticText(General,label=' No spin inversion allowed'),0,WACV)
     
    748791            spCode = {-1:'red',1:'black'}
    749792            for isym,sym in enumerate(GenSym):
    750                 spinSizer.Add(wx.StaticText(General,label='%s: '%(sym.strip())),0,WACV)               
     793                spinSizer.Add(wx.StaticText(General,label=' %s: '%(sym.strip())),0,WACV)               
    751794                spinOp = wx.ComboBox(General,value=spCode[SGData['SGSpin'][isym]],choices=spinColor,
    752795                    style=wx.CB_READONLY|wx.CB_DROPDOWN)               
     
    759802            SGData['OprNames'] = OprNames
    760803            SGData['SpnFlp'] = SpnFlp
    761             spinSizer.Add(wx.StaticText(General,label=' OG Magnetic space group: %s  '%(MagSym)),0,WACV)
     804            spinSizer.Add(wx.StaticText(General,label=' Magnetic space group: %s  '%(MagSym)),0,WACV)
    762805            showSpins = wx.CheckBox(General,label=' Show spins?')
    763806            showSpins.Bind(wx.EVT_CHECKBOX,OnShowSpins)
    764807            spinSizer.Add(showSpins,0,WACV)
    765808            magSizer.Add(spinSizer)
     809            dminSizer = wx.BoxSizer(wx.HORIZONTAL)
     810            dminSizer.Add(wx.StaticText(General,label=' Magnetic reflection d-min: '),0,WACV)
     811            dminVal = wx.TextCtrl(General,value='%.4f'%(generalData['MagDmin']),style=wx.TE_PROCESS_ENTER)
     812            dminVal.Bind(wx.EVT_TEXT_ENTER,OnDminVal)       
     813            dminVal.Bind(wx.EVT_KILL_FOCUS,OnDminVal)
     814            dminSizer.Add(dminVal,0,WACV)
     815            magSizer.Add(dminSizer,0,WACV)
    766816            return magSizer
    767817           
     
    22112261        if indx:
    22122262            generalData = data['General']
     2263            Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])
    22132264            SpnFlp = generalData['SGData'].get('SpnFlp',[])
    22142265            colLabels = [Atoms.GetColLabelValue(c) for c in range(Atoms.GetNumberCols())]
     
    22522303                            atom[cuij:cuij+6] = Uij
    22532304                        if cmx:
    2254                             atom[cmx:cmx+3] = np.inner(M,np.array(atom[cmx:cmx+3]))
     2305                            mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     2306                            atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    22552307                        if New:
    22562308                            atomData.append(atom)
     
    42004252            atomData = data['Drawing']['Atoms']
    42014253            generalData = data['General']
     4254            Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])
    42024255            SGData = generalData['SGData']
    42034256            SpnFlp = SGData.get('SpnFlp',[])
     
    42274280                            if cmx:
    42284281                                opNum = G2spc.GetOpNum(OprNum,SGData)
    4229                                 atom[cmx:cmx+3] = np.inner(M,np.array(atom[cmx:cmx+3]))
     4282                                mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4283                                atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    42304284                            if atom[cui] == 'A':
    42314285                                Uij = atom[cuij:cuij+6]
     
    42764330                            if cmx:
    42774331                                opNum = G2spc.GetOpNum(item[2],SGData)
    4278                                 atom[cmx:cmx+3] = np.inner(M,np.array(atom[cmx:cmx+3]))
     4332                                mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4333                                atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    42794334                            atom[cs-1] = str(item[2])+'+'
    42804335                            atom[cuij:cuij+6] = item[1]
     
    43074362            atomData = data['Drawing']['Atoms']
    43084363            generalData = data['General']
     4364            Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])
    43094365            SGData = generalData['SGData']
    43104366            SpnFlp = SGData.get('SpnFlp',[])
     
    43304386                        if cmx:
    43314387                            opNum = G2spc.GetOpNum(OprNum,SGData)
    4332                             atom[cmx:cmx+3] = np.inner(M,np.array(atom[cmx:cmx+3]))
     4388                            mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4389                            atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    43334390                        atomOp = atom[cs-1]
    43344391                        newOp = str(((Opr+1)+100*Cent)*(1-2*Inv))+'+'+ \
     
    43974454                                    if cmx:
    43984455                                        opNum = G2spc.GetOpNum(OpN,SGData)
    4399                                         newAtom[cmx:cmx+3] = np.inner(M,np.array(newAtom[cmx:cmx+3]))
     4456                                        mom = np.inner(np.array(newAtom[cmx:cmx+3]),Bmat)
     4457                                        newAtom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    44004458                                    atomData.append(newAtom[:cij+9])  #not SS stuff
    44014459            finally:
     
    44184476            cuij = cui+2
    44194477            generalData = data['General']
     4478            Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])           
    44204479            SGData = generalData['SGData']
    44214480            SpnFlp = SGData.get('SpnFlp',[])
     
    44354494                            if cmx:
    44364495                                opNum = G2spc.GetOpNum(item[2],SGData)
    4437                                 atom[cmx:cmx+3] = np.inner(SGData['SGOps'],np.array(atom[cmx:cmx+3]))
     4496                                mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4497                                atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    44384498                            atom[cs-1] = str(item[2])+'+' \
    44394499                                +str(item[3][0])+','+str(item[3][1])+','+str(item[3][2])
     
    44574517                            if cmx:
    44584518                                opNum = G2spc.GetOpNum(item[1],SGData)
    4459                                 atom[cmx:cmx+3] = np.inner(np.array(atom[cmx:cmx+3]),M)
     4519                                mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4520                                atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)
    44604521                            atom[cs-1] = str(item[1])+'+' \
    44614522                                +str(item[2][0])+','+str(item[2][1])+','+str(item[2][2])
  • trunk/GSASIIpwd.py

    r2419 r2473  
    17581758            YI += (Icoef[1]*Eterm/x**5)
    17591759            if 'Exponential' in Itype:
    1760                 for i in range(3,12,2):
     1760                for i in range(3,11,2):
    17611761                    Eterm = np.exp(-Icoef[i+1]*x**((i+1)/2))
    17621762                    YI += Icoef[i]*Eterm
  • trunk/GSASIIspc.py

    r2470 r2473  
    719719    GenSym = SGData['GenSym']
    720720    if not len(SpnFlp):
     721        SGLaue['MagPtGp'] = SGLaue
    721722        return SGData['SpGrp']
    722723    magSym = SGData['SpGrp'].split()
    723724    if len(SpnFlp) == 1:    #ok
     725        SGData['MagPtGp'] = SGLaue
    724726        if SpnFlp[-1] == -1:
    725727            magSym[1] += "'"
     728            SGData['MagPtGp'] += "'"
    726729        return ' '.join(magSym)
    727730    if SGLaue in ['mmm',]:
     731        SGData['MagPtGp'] = ''
    728732        for i in [0,1,2]:
     733            SGData['MagPtGp'] += 'm'
    729734            if SpnFlp[i] < 0:
    730735                magSym[i+1] += "'"
     736                SGData['MagPtGp'] += "'"
    731737        if len(GenSym) > 3:
    732738            if magSym[0] == 'F':
     
    743749    elif SGLaue == '6/mmm': #ok
    744750        if len(GenSym) == 2:
     751            magPtGp = ['6','m','m']
    745752            for i in [0,1]:
    746753                if SpnFlp[i] < 0:
    747754                    magSym[i+2] += "'"
     755                    magPtGp[i+1] += "'"
    748756            if SpnFlp[0]*SpnFlp[1] < 0:
    749757                magSym[1] += "'"
     758                magPtGp[0] += "'"
    750759        else:
    751760            sym = magSym[1].split('/')
     761            Ptsym = ['6','m']
     762            magPtGp = ['','m','m']
    752763            for i in [0,1,2]:
    753764                if SpnFlp[i] < 0:
    754765                    if i:
    755766                        magSym[i+1] += "'"
     767                        magPtGp[i] += "'"
    756768                    else:
    757769                        sym[1] += "'"
     770                        Ptsym[0] += "'"
    758771            if SpnFlp[1]*SpnFlp[2] < 0:
    759772                sym[0] += "'"                   
     773                Ptsym[0] += "'"                   
    760774            magSym[1] = '/'.join(sym)
     775            magPtGp[0] = '/'.join(Ptsym)
     776        SGData['MagPtGp'] = ''.join(magPtGp)
    761777    elif SGLaue == '4/mmm':
    762778        if len(GenSym) == 2:
     779            magPtGp = ['4','m','m']
    763780            for i in [0,1]:
    764781                if SpnFlp[i] < 0:
    765782                    magSym[i+2] += "'"
     783                    magPtGp[i+1] += "'"
    766784            if SpnFlp[0]*SpnFlp[1] < 0:
    767785                magSym[1] += "'"
     786                magPtGp[0] += "'"
    768787        else:
    769788            if '/' in magSym[1]:    #P 4/m m m, etc.
    770789                sym = magSym[1].split('/')
     790                Ptsym = ['4','m']
     791                magPtGp = ['','m','m']
    771792                for i in [0,1,2]:
    772793                    if SpnFlp[i] < 0:
    773794                        if i:
    774795                            magSym[i+1] += "'"
     796                            magPtGp[i] += "'"
    775797                        else:
    776798                            sym[1] += "'"
     799                            Ptsym[1] += "'"
    777800                if SpnFlp[1]*SpnFlp[2] < 0:
    778801                    sym[0] += "'"                   
     802                    Ptsym[0] += "'"                   
    779803                magSym[1] = '/'.join(sym)
     804                magPtGp[0] = '/'.join(Ptsym)
    780805                if SpnFlp[3] < 0:
    781806                    magSym[0] += '(P)'
     
    788813                if SpnFlp[2] < 0:
    789814                    magSym[0] += '(P)'
     815        SGData['MagPtGp'] = ''.join(magPtGp)
    790816    elif SGLaue in ['2/m','4/m','6/m']: #all ok
    791817        Uniq = {'a':1,'b':2,'c':3,'':1}
     
    794820            id = [0,Uniq[SGData['SGUniq']]]
    795821        sym = magSym[id[1]].split('/')
     822        Ptsym = SGLaue.split('/')
    796823        if len(GenSym) == 3:
    797824            for i in [0,1,2]:
     
    801828                    else:
    802829                        sym[i] += "'"
     830                        Ptsym[i] += "'"
    803831        else:
    804832            for i in [0,1]:
     
    808836                    else:
    809837                        sym[i] += "'"
     838                        Ptsym[i] += "'"
     839        SGData['MagPtGp'] = '/'.join(Ptsym)
    810840        magSym[id[1]] = '/'.join(sym)
    811841    elif SGLaue in ['3','3m1','31m']:   #ok
    812842#        GSASIIpath.IPyBreak()
    813         magSym[0] = magSym[0].split('(')[0]
     843        Ptsym = list(SGLaue)
    814844        if len(GenSym) == 1:    #all ok
    815845            id = 2
     
    821851            if SpnFlp[0] < 0:
    822852                magSym[id] += "'"
     853                Ptsym[id-1] += "'"
    823854        elif len(GenSym) == 2:
    824855            if 'R' in GenSym[1]:
     
    826857                if SpnFlp[0] < 0:
    827858                    magSym[-1] += "'"
     859                    Ptsym[-1] += "'"
    828860            else:
    829861                i,j = [1,2]
     
    831863                    i,j = [1,3]
    832864                magSym[i].strip("'")
     865                Ptsym[i-1].strip("'")
    833866                magSym[j].strip("'")
     867                Ptsym[j-1].strip("'")
    834868                if SpnFlp[:2] == [1,-1]:
    835869                    magSym[i] += "'"
     870                    Ptsym[i-1] += "'"
    836871                elif SpnFlp[:2] == [-1,-1]:
    837872                    magSym[j] += "'"
     873                    Ptsym[j-1] += "'"
    838874                elif SpnFlp[:2] == [-1,1]:
    839875                    magSym[i] += "'"
     876                    Ptsym[i-1] += "'"
    840877                    magSym[j] += "'"
     878                    Ptsym[j-1] += "'"
    841879        else:
    842880            if 'c' not in magSym[2]:
    843881                i,j = [1,2]
    844882                magSym[i].strip("'")
     883                Ptsym[i-1].strip("'")
    845884                magSym[j].strip("'")
     885                Ptsym[j-1].strip("'")
    846886                if SpnFlp[:2] == [1,-1]:
    847887                    magSym[i] += "'"
     888                    Ptsym[i-1] += "'"
    848889                elif SpnFlp[:2] == [-1,-1]:
    849890                    magSym[j] += "'"
     891                    Ptsym[j-1] += "'"
    850892                elif SpnFlp[:2] == [-1,1]:
    851893                    magSym[i] += "'"
     894                    Ptsym[i-1] += "'"
    852895                    magSym[j] += "'"
     896                    Ptsym[j-1] += "'"
     897        SGData['MagPtGp'] = ''.join(Ptsym)
    853898    elif SGData['SGPtGrp'] == '23' and len(magSym):
     899        SGData['MagPtGp'] = '23'
    854900        if SpnFlp[0] < 0:
    855901            magSym[0] += '(P)'
    856902    elif SGData['SGPtGrp'] == 'm3':
     903        SGData['MagPtGp'] = "m3"
    857904        if SpnFlp[0] < 0:
    858905            magSym[1] += "'"
    859906            magSym[2] += "'"
     907            SGData['MagPtGp'] = "m'3'"
    860908        if SpnFlp[1] < 0:
    861909            magSym[0] += '(P)'
    862             if not 'm' in magSym[1]:
     910            if not 'm' in magSym[1]:    #only Ia3
    863911                magSym[1].strip("'")
     912                SGData['MagPtGp'] = "m3'"
    864913    elif SGData['SGPtGrp'] in ['432','-43m']:
     914        Ptsym = SGData['SGPtGrp'].split('3')
    865915        if SpnFlp[0] < 0:
    866916            magSym[1] += "'"
     917            Ptsym[0] += "'"
    867918            magSym[3] += "'"
     919            Ptsym[1] += "'"
    868920        if SpnFlp[1] < 0:
    869921            magSym[0] += '(P)'
     922        SGData['MagPtGp'] = '3'.join(Ptsym)
    870923    elif SGData['SGPtGrp'] == 'm-3m':
     924        Ptsym = ['m','3','m']
    871925        if SpnFlp[:2] == [-1,1]:
    872926            magSym[1] += "'"
     927            Ptsym[0] += "'"
    873928            magSym[2] += "'"
     929            Ptsym[1] += "'"
    874930        elif SpnFlp[:2] == [1,-1]:
    875931            magSym[3] += "'"
     932            Ptsym[2] += "'"
    876933        elif SpnFlp[:2] == [-1,-1]:
    877934            magSym[1] += "'"
     935            Ptsym[0] += "'"
    878936            magSym[2] += "'"
     937            Ptsym[1] += "'"
    879938            magSym[3] += "'"
     939            Ptsym[2] += "'"
    880940        if SpnFlp[2] < 0:
    881941            magSym[0] += '(P)'
     942        SGData['MagPtGp'] = ''.join(Ptsym)
    882943#    print SpnFlp
    883944    return ' '.join(magSym)
  • trunk/GSASIIstrIO.py

    r2450 r2473  
    808808            print >>pFile,' %8s %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f' %  \
    809809                (Ename.ljust(8),fa[0],fa[1],fa[2],fa[3],fb[0],fb[1],fb[2],fb[3],ffdata['fc'])
     810               
     811    def PrintMFtable(MFtable):
     812        print >>pFile,'\n <j0> Magnetic scattering factors:'
     813        print >>pFile,'   Symbol     mfa                                    mfb                                     mfc'
     814        print >>pFile,99*'-'
     815        for Ename in MFtable:
     816            mfdata = MFtable[Ename]
     817            fa = mfdata['mfa']
     818            fb = mfdata['mfb']
     819            print >>pFile,' %8s %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f' %  \
     820                (Ename.ljust(8),fa[0],fa[1],fa[2],fa[3],fb[0],fb[1],fb[2],fb[3],mfdata['mfc'])
     821        print >>pFile,'\n <j2> Magnetic scattering factors:'
     822        print >>pFile,'   Symbol     nfa                                    nfb                                     nfc'
     823        print >>pFile,99*'-'
     824        for Ename in MFtable:
     825            mfdata = MFtable[Ename]
     826            fa = mfdata['nfa']
     827            fb = mfdata['nfb']
     828            print >>pFile,' %8s %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f %9.5f' %  \
     829                (Ename.ljust(8),fa[0],fa[1],fa[2],fa[3],fb[0],fb[1],fb[2],fb[3],mfdata['nfc'])
    810830               
    811831    def PrintBLtable(BLtable):
     
    915935                print >>pFile,line
    916936               
     937    def PrintMoments(General,Atoms):
     938        cx,ct,cs,cia = General['AtomPtrs']
     939        cmx = cx+4
     940        print >>pFile,'\n Magnetic moments:'
     941        line = '   name    type  refine?  Mx        My        Mz    '
     942        print >>pFile,line
     943        print >>pFile,135*'-'
     944        for i,at in enumerate(Atoms):
     945            line = '%7s'%(at[ct-1])+'%7s'%(at[ct])+'%7s'%(at[ct+1])+'%10.5f'%(at[cmx])+'%10.5f'%(at[cmx+1])+ \
     946                '%10.5f'%(at[cmx+2])
     947            print >>pFile,line
     948       
     949               
    917950    def PrintWaves(General,Atoms):
    918951        cx,ct,cs,cia = General['AtomPtrs']
     
    10451078    pawleyLookup = {}
    10461079    FFtables = {}                   #scattering factors - xrays
     1080    MFtables = {}                   #Mag. form factors
    10471081    BLtables = {}                   # neutrons
    10481082    Natoms = {}
     
    10611095        FFtables.update(FFtable)
    10621096        BLtables.update(BLtable)
     1097        if General['Type'] == 'magnetic':
     1098            MFtable = G2el.GetMFtable(General['AtomTypes'])
     1099            MFtables.update(MFtable)
    10631100        Atoms = PhaseData[name]['Atoms']
    10641101        if Atoms and not General.get('doPawley'):
     
    11151152                    phaseDict.update({pfx+'AU11:'+str(i):at[cia+2],pfx+'AU22:'+str(i):at[cia+3],pfx+'AU33:'+str(i):at[cia+4],
    11161153                        pfx+'AU12:'+str(i):at[cia+5],pfx+'AU13:'+str(i):at[cia+6],pfx+'AU23:'+str(i):at[cia+7]})
     1154                if General['Type'] == 'magnetic':
     1155                    phaseDict.update({pfx+'AMx:'+str(i):at[cx+4],pfx+'AMy:'+str(i):at[cx+5],pfx+'AMz:'+str(i):at[cx+6]})
    11171156                if 'F' in at[ct+1]:
    11181157                    phaseVary.append(pfx+'Afrac:'+str(i))
     
    11631202                                    eqv[1] /= coef
    11641203                                G2mv.StoreEquivalence(name,equiv[1:])
     1204                if 'M' in at[ct+1]:
     1205                    pass    #magnetic moment vary here
    11651206                if General.get('Modulated',False):
    11661207                    AtomSS = at[-1]['SS1']
     
    12351276                PrintFFtable(FFtable)
    12361277                PrintBLtable(BLtable)
     1278                if General['Type'] == 'magnetic':
     1279                    PrintMFtable(MFtable)
    12371280                print >>pFile,''
     1281                #how do we print magnetic symmetry table? TBD
    12381282                if len(SSGtext):    #if superstructure
    12391283                    for line in SSGtext: print >>pFile,line
     
    12541298                PrintRBObjects(resRBData,vecRBData)
    12551299                PrintAtoms(General,Atoms)
     1300                if General['Type'] == 'magnetic':
     1301                    PrintMoments(General,Atoms)
    12561302                if General.get('Modulated',False):
    12571303                    PrintWaves(General,Atoms)
     
    15301576        print >>pFile,'\n Atoms:'
    15311577        line = '   name      x         y         z      frac   Uiso     U11     U22     U33     U12     U13     U23'
    1532         if General['Type'] == 'magnetic':
    1533             line = line[:24]+'   Mx     My     Mz'+line[24:]
    1534         elif General['Type'] == 'macromolecular':
     1578        if General['Type'] == 'macromolecular':
    15351579            line = ' res no residue chain '+line
    15361580        cx,ct,cs,cia = General['AtomPtrs']
     
    15751619                    else:
    15761620                        sigstr += 8*' '
     1621            print >>pFile,name
     1622            print >>pFile,valstr
     1623            print >>pFile,sigstr
     1624           
     1625    def PrintMomentsAndSig(General,Atoms,atomsSig):
     1626        print >>pFile,'\n Magnetic Moments:'    #add magnitude & angle, etc.? TBD
     1627        line = '   name      Mx        My        Mz'
     1628        cx,ct,cs,cia = General['AtomPtrs']
     1629        cmx = cx+4
     1630        print >>pFile,line
     1631        print >>pFile,135*'-'
     1632        fmt = {0:'%7s',ct:'%7s',cmx:'%10.5f',cmx+1:'%10.5f',cmx+2:'%10.5f'}
     1633        noFXsig = {cmx:[10*' ','%10s'],cmx+1:[10*' ','%10s'],cmx+2:[10*' ','%10s']}
     1634        for i,at in enumerate(Atoms):
     1635            name = fmt[0]%(at[ct-1])+fmt[1]%(at[ct])+':'
     1636            valstr = ' values:'
     1637            sigstr = ' sig   :'
     1638            for ind in range(cmx,cmx+3):
     1639                sigind = str(i)+':'+str(ind)
     1640                valstr += fmt[ind]%(at[ind])                   
     1641                if sigind in atomsSig:
     1642                    sigstr += fmt[ind]%(atomsSig[sigind])
     1643                else:
     1644                    sigstr += noFXsig[ind][1]%(noFXsig[ind][0])
    15771645            print >>pFile,name
    15781646            print >>pFile,valstr
     
    19462014                   
    19472015            PrintAtomsAndSig(General,Atoms,atomsSig)
     2016            if General['Type'] == 'magnetic':
     2017                PrintMomentsAndSig(General,Atoms,atomsSig)
    19482018            if General.get('Modulated',False):
    19492019                PrintWavesAndSig(General,Atoms,wavesSig)
     
    21112181                elif 'T' in inst['Type'][0]:
    21122182                    dmin = limits[0]/inst['difC'][1]
     2183                if Phases[phase]['General']['Type'] == 'magnetic':
     2184                    dmin = max(dmin,Phases[phase]['General']['MagDmin'])
    21132185                pfx = str(pId)+':'+str(hId)+':'
    21142186                for item in ['Scale','Extinction']:
  • trunk/imports/G2phase.py

    r2470 r2473  
    240240        elif NPhas[result] in ['2','3']:
    241241            Ptype = 'magnetic'
     242            MagDmin = 1.0
    242243        elif NPhas[result] == '4':
    243244            Ptype = 'macromolecular'
     
    261262                    self.warnings += "Change this in phase's General tab."                       
    262263            elif 'SPNFLP' in key:
    263                 SpnFlp = [int(s) for s in EXPphase[key].split()]               
     264                SpnFlp = [int(s) for s in EXPphase[key].split()]
     265                if SGData['SpGrp'][0] in ['A','B','C','I','R','F']:
     266                    SpnFlp += [1,1,1,1]
     267            elif 'MXDSTR' in key:
     268                MagDmin = float(EXPphase[key][:10])               
    264269            elif 'OD    ' in key:
    265270                SHdata = EXPphase[key].split() # may not have all 9 values
     
    343348        elif general['Type'] =='magnetic':
    344349            general['AtomPtrs'] = [3,1,10,12]
    345             general['SGData']['SGSpin'] = SpnFlp   
     350            general['SGData']['SGSpin'] = SpnFlp
     351            general['MagDmin'] = MagDmin   
    346352        else:   #nuclear
    347353            general['AtomPtrs'] = [3,1,7,9]   
Note: See TracChangeset for help on using the changeset viewer.