Changeset 2486


Ignore:
Timestamp:
Oct 12, 2016 1:06:57 PM (5 years ago)
Author:
vondreele
Message:

fix mag form factor lookup - some aren't chemical valences (e.g. Fe+4)
fix mag form factor periodic table - nonmagnetic atoms now not shown
fix powder reflection mark & diff curve placement issues
fix issues with mag structure drawings - fill unit cell, etc.
fix structure transform to make magnetic cells (still needs making of constraints)
fix problem of mustrain & hstrain coeff changes with change in space group
add print to file of covariance matrix - user request
fix magnetic moment site symmetry restrictions
work on mag structure factor calcs.
change EXP file importer to ignore magnetic symmetry from GSAS

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/ElementTable.py

    r1589 r2486  
    123123    (["None",],                  15.5,7.5, "No element choice",REcolor,     0.000,(161,54,212)),
    124124    ]
     125
     126MagElTable = [
     127    (["Sc","Sc+1","Sc+2","Sc+3"],                       2,3, "Scandium",    Metcolor,        0.0410,(230,230,230)),
     128    (["Ti","Ti+2","Ti+3"],                              3,3, "Titanium",    Metcolor,        0.0460,(191,194,199)),
     129    (["V","V+1","V+2","V+3"],                           4,3, "Vanadium",    Metcolor,        0.0510,(166,166,171)),
     130    (["Cr","Cr+1","Cr+2","Cr+3","Cr+4"],                5,3, "Chromium",    Metcolor,        0.0560,(138,153,199)),
     131    (["Mn","Mn+1","Mn+2","Mn+3","Mn+4"],                6,3, "Manganese",   Metcolor,        0.0616,(156,122,199)),
     132    (["Fe","Fe+1","Fe+2","Fe+3","Fe+4"],                7,3, "Iron",        Metcolor,        0.0680,(224,102,51)),
     133    (["Co","Co+1","Co+2","Co+3","Co+4"],                8,3, "Cobalt",      Metcolor,        0.0740,(240,144,160)),
     134    (["Ni","Ni+1","Ni+2","Ni+3","Ni+4"],                9,3, "Nickel",      Metcolor,        0.0815,(80,208,80)),
     135    (["Cu","Cu+1","Cu+2","Cu+3","Cu+4"],               10,3, "Copper",      Metcolor,        0.0878,(200,128,51)),
     136    (["Y"],                                             2,4, "Yittrium",    Metcolor,         0.180,(148,255,255)),
     137    (["Zr","Zr+1"],                                     3,4, "Zirconium",   Metcolor,         0.192,(148,224,224)),
     138    (["Nb","Nb+1"],                                     4,4, "Niobium",     Metcolor,         0.204,(115,194,201)),
     139    (["Mo","Mo+1"],                                     5,4, "Molybdenium", Metcolor,         0.216,(84,181,181)),
     140    (["Tc","Tc+1"],                                     6,4, "Technetium",  Metcolor,         0.228,(59,158,158)),
     141    (["Ru","Ru+1"],                                     7,4, "Ruthenium",   Metcolor,         0.246,(36,143,143)),
     142    (["Rh","Rh+1"],                                     8,4, "Rhodium",     Metcolor,         0.258,(10,125,140)),
     143    (["Pd","Pd+1"],                                     9,4, "Palladium",   Metcolor,         0.270,(0,105,133)),
     144    (["Ce+2"],                                      3.5,6.5, "Cerium",      REcolor,          0.474,(255,255,199)),
     145    (["Nd+2"],                                      5.5,6.5, "Neodymium",   REcolor,          0.516,(199,255,199)),
     146    (["Sm+2","Sm+3"],                               7.5,6.5, "Samarium",    REcolor,          0.558,(143,255,199)),
     147    (["Eu+2","Eu+3"],                               8.5,6.5, "Europium",    REcolor,          0.582,(97,255,199)),
     148    (["Gd+2","Gd+3"],                               9.5,6.5, "Gadolinium",  REcolor,          0.610,(69,255,199)),
     149    (["Tb+2","Tb+3"],                              10.5,6.5, "Terbium",     REcolor,          0.624,(48,255,199)),
     150    (["Dy+2","Dy+3"],                              11.5,6.5, "Dysprosium",  REcolor,          0.648,(31,255,199)),
     151    (["Ho+2","Ho+3"],                              12.5,6.5, "Holmium",     REcolor,          0.672,(0,255,156)),
     152    (["Er+2","Er+3"],                              13.5,6.5, "Erbium",      REcolor,          0.696,(0,230,117)),
     153    (["Tm+2","Tm+3"],                              14.5,6.5, "Thulium",     REcolor,          0.723,(0,212,82)),
     154    (["Yb+2","Yb+3"],                              15.5,6.5, "Ytterbium",   REcolor,          0.750,(0,191,56)),
     155    (["U+3","U+4","U+5"],                           5.5,7.5, "Uranium",     REcolor,          1.470,(0,143,255)),
     156    (["Np+3","Np+4","Np+5","Np+6"],                 6.5,7.5, "Neptunium",   REcolor,       1.536,(0,128,255)),
     157    (["Pu+3","Pu+4","Pu+5","Pu+6"],                 7.5,7.5, "Plutonium",   REcolor,       1.584,(0,107,255)),
     158    (["Am+2","Am+3","Am+4","Am+5","Am+6","Am+7"],   8.5,7.5, "Americium",   REcolor,          1.626,(84,92,242)),
     159    ]
  • trunk/GSASII.py

    r2481 r2486  
    15341534                rd.powderdata[3] = np.zeros_like(rd.powderdata[0])
    15351535                rd.powderdata[4] = np.zeros_like(rd.powderdata[0])
    1536                 rd.powderdata[5] = np.zeros_like(rd.powderdata[0])                 
     1536                rd.powderdata[5] = np.zeros_like(rd.powderdata[0])
     1537            Ymax = np.max(rd.powderdata[1])                 
    15371538            valuesdict = {
    15381539                'wtFactor':1.0,
    15391540                'Dummy':False,
    15401541                'ranId':ran.randint(0,sys.maxint),
    1541                 'Offset':[0.0,0.0],'delOffset':0.02,'refOffset':-1.0,'refDelt':0.01,
     1542                'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-.1*Ymax,'refDelt':0.1*Ymax,
    15421543                'qPlot':False,'dPlot':False,'sqrtPlot':False
    15431544                }
     
    17291730        HistName = G2obj.MakeUniqueLabel(HistName,PWDRlist)  # make new histogram names unique
    17301731        Id = self.PatternTree.AppendItem(parent=self.root,text=HistName)
     1732        Ymax = np.max(rd.powderdata[1])
    17311733        valuesdict = {
    17321734            'wtFactor':1.0,
    17331735            'Dummy':True,
    17341736            'ranId':ran.randint(0,sys.maxint),
    1735             'Offset':[0.0,0.0],'delOffset':0.02,'refOffset':-1.0,'refDelt':0.01,
     1737            'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-.1*Ymax,'refDelt':0.1*Ymax,
    17361738            'qPlot':False,'dPlot':False,'sqrtPlot':False
    17371739            }
     
    28152817                    if Id:
    28162818                        Sample = G2pdG.SetDefaultSample()
     2819                        Ymax = np.max(Ysum)
    28172820                        valuesdict = {
    28182821                            'wtFactor':1.0,
    28192822                            'Dummy':False,
    28202823                            'ranId':ran.randint(0,sys.maxint),
    2821                             'Offset':[0.0,0.0],'delOffset':0.02,'refOffset':-1.0,'refDelt':0.01,
     2824                            'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-.1*Ymax,'refDelt':0.1*Ymax,
    28222825                            'qPlot':False,'dPlot':False,'sqrtPlot':False
    28232826                            }
  • trunk/GSASIIElem.py

    r2478 r2486  
    184184    return El
    185185   
    186 def GetAtomInfo(El):
     186def GetAtomInfo(El,ifMag=False):
    187187    'reads element information from atmdata.py'
    188188    import ElementTable as ET
    189     Elements = [elem[0][0] for elem in ET.ElTable]
     189    Elem = ET.ElTable
     190    if ifMag:
     191        Elem = ET.MagElTable
     192    Elements = [elem[0][0] for elem in Elem]
    190193    AtomInfo = {}
    191194    ElS = getElSym(El)
    192     if El not in atmdata.XrayFF:
     195    if El not in atmdata.XrayFF and El not in atmdata.MagFF:
    193196        if ElS not in atmdata.XrayFF:
    194197            print('Atom type '+El+' not found, using UNK')
     
    199202    AtomInfo['Symbol'] = El
    200203    AtomInfo['Color'] = ET.ElTable[Elements.index(ElS)][6]
    201     AtomInfo['Z'] = atmdata.XrayFF[El]['Z']
     204    AtomInfo['Z'] = atmdata.XrayFF[ElS]['Z']
    202205    isotopes = [ky for ky in atmdata.AtmBlens.keys() if ElS == ky.split('_')[0]]
    203206    isotopes.sort()
  • trunk/GSASIIElemGUI.py

    r1972 r2486  
    2626    "Makes periodic table widget for picking element - caller maintains element list"
    2727    Elem=None
    28     def _init_ctrls(self, prnt):
     28    def _init_ctrls(self,prnt,ifMag=False):
    2929        wx.Dialog.__init__(self, id=-1, name='PickElement',
    3030              parent=prnt, pos=wx.DefaultPosition,
     
    3737       
    3838        i=0
    39         for E in ET.ElTable:
     39        Elems = ET.ElTable
     40        if ifMag:
     41            Elems = ET.MagElTable
     42        for E in Elems:
    4043            if E[1] < 0: continue
    4144            if self.oneOnly:
     
    4851            i+=1
    4952
    50     def __init__(self, parent,oneOnly=False,ifNone=False):
     53    def __init__(self, parent,oneOnly=False,ifNone=False,ifMag=False):
    5154        'Needs a doc string'
    5255        self.oneOnly = oneOnly
    5356        self.ifNone = ifNone
    54         self._init_ctrls(parent)
     57        self._init_ctrls(parent,ifMag=ifMag)
    5558       
    5659    def ElButton(self, name, pos, tip, color):
  • trunk/GSASIIIO.py

    r2460 r2486  
    912912            parms = ['LXC',data['wavelength'],0.0,Azms[i]]
    913913        Y = G2frame.Integrate[0][i]
     914        Ymax = np.max(Y)
    914915        W = np.where(Y>0.,1./Y,1.e-6)                    #probably not true
    915916        Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=Aname)
     
    938939            'Dummy':False,
    939940            'ranId':ran.randint(0,sys.maxint),
    940             'Offset':[0.0,0.0],'delOffset':0.02,'refOffset':-1.0,'refDelt':0.01,
     941            'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-0.1*Ymax,'refDelt':0.1*Ymax,
    941942            'qPlot':False,'dPlot':False,'sqrtPlot':False
    942943            }
  • trunk/GSASIIgrid.py

    r2485 r2486  
    607607                SGTxt.SetValue(self.Phase['General']['SGData']['SpGrp'])
    608608                msg = 'Space Group Information'
    609                 dlg = SGMessageBox(self.panel,msg,text,table)
    610                 dlg.Show()
    611                 dlg.Destroy()
     609                SGMessageBox(self.panel,msg,text,table).Show()
     610            if self.Phase['General']['Type'] == 'magnetic':
     611                Nops = len(SGData['SGOps'])*len(SGData['SGCen'])
     612                if SGData['SGInv']:
     613                    Nops *= 2
     614                SGData['SpnFlp'] = Nops*[1,]
    612615#            if self.Phase['General']['Type'] in ['modulated',]:
    613616#                self.Phase['General']['SuperSg'] = SetDefaultSSsymbol()
  • trunk/GSASIIlattice.py

    r2484 r2486  
    282282        if cm:
    283283            mag = np.sqrt(np.sum(np.array(atom[cm:cm+3])**2))
    284             mom = np.inner(np.array(atom[cm:cm+3]),oBmat)
    285             mom = np.inner(mom,invTrans.T)
    286             mom = np.inner(mom,nAmat)
    287             mom /= np.sqrt(np.sum(mom**2))
    288             atom[cm:cm+3] = mom*mag
     284            if mag:
     285                mom = np.inner(np.array(atom[cm:cm+3]),oBmat)
     286                mom = np.inner(mom,invTrans.T)
     287                mom = np.inner(mom,nAmat)
     288                mom /= np.sqrt(np.sum(mom**2))
     289                atom[cm:cm+3] = mom*mag
    289290    newPhase['Atoms'] = newAtoms
    290291    newPhase['Atoms'] = GetUnique(newPhase)
  • trunk/GSASIIphsGUI.py

    r2485 r2486  
    469469                    atom[cs] = Sytsym
    470470                    atom[cs+1] = Mult
     471                NShkl = len(G2spc.MustrainNames(SGData))
     472                NDij = len(G2spc.HStrainNames(SGData))
     473                UseList = data['Histograms']
     474                for hist in UseList:
     475                    UseList[hist]['Mustrain'][4:6] = [NShkl*[0.01,],NShkl*[False,]]
     476                    UseList[hist]['HStrain'] = [NDij*[0.0,],NDij*[False,]]
    471477                wx.CallAfter(UpdateGeneral)
    472478               
     
    13861392            phaseName += ' mag'
    13871393        newPhase = G2lat.TransformPhase(data,newPhase,Trans,Vec,ifMag)
     1394
     1395        generalData = newPhase['General']
     1396        SGData = generalData['SGData']
     1397        NShkl = len(G2spc.MustrainNames(SGData))
     1398        NDij = len(G2spc.HStrainNames(SGData))
     1399        UseList = newPhase['Histograms']
     1400        for hist in UseList:
     1401            UseList[hist]['Mustrain'][4:6] = [NShkl*[0.01,],NShkl*[False,]]
     1402            UseList[hist]['HStrain'] = [NDij*[0.0,],NDij*[False,]]
    13881403        newPhase['General']['Map'] = mapDefault.copy()
    13891404        sub = G2frame.PatternTree.AppendItem(parent=
    13901405            G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
    13911406        G2frame.PatternTree.SetItemPyData(sub,newPhase)
     1407        G2gd.MovePatternTreeToGrid(G2frame,sub) #bring up new phase General tab
    13921408        # if nuc - mag transformtion: make constraints here? Needed for Type 4 magnetics
    13931409       
     
    16031619            r,c =  event.GetRow(),event.GetCol()
    16041620            if Atoms.GetColLabelValue(c) == 'Type':
    1605                 PE = G2elemGUI.PickElement(G2frame)
     1621                PE = G2elemGUI.PickElement(G2frame,ifMag=ifMag)
    16061622                if PE.ShowModal() == wx.ID_OK:
    16071623                    if PE.Elem != 'None':                       
     
    18101826        Types += 7*[wg.GRID_VALUE_FLOAT+':10,5',]
    18111827        colLabels = ['Name','Type','refine','x','y','z','frac','site sym','mult','I/A','Uiso','U11','U22','U33','U12','U13','U23']
     1828        ifMag = False
    18121829        if generalData['Type'] == 'macromolecular':
    18131830            colLabels = ['res no','residue','chain'] + colLabels
     
    18161833                wg.GRID_VALUE_STRING] + Types
    18171834        elif generalData['Type'] == 'magnetic':
     1835            ifMag = True
    18181836            colLabels = colLabels[:7]+['Mx','My','Mz']+colLabels[7:]
    18191837            Types = Types[:7]+3*[wg.GRID_VALUE_FLOAT+':10,4',]+Types[7:]
     
    29742992                    if PE.ShowModal() == wx.ID_OK:
    29752993                        if PE.Elem != 'None':
    2976                             atType =                  PE.Elem.strip()       
     2994                            atType = PE.Elem.strip()       
    29772995                            Layer['Atoms'][r][c] = atType
    29782996                            name = Layer['Atoms'][r][c]
     
    43204338                                opNum = G2spc.GetOpNum(OprNum,SGData)
    43214339                                mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
    4322                                 atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4340                                print OprNum,newOp,opNum,SpnFlp
     4341                                if Inv:
     4342                                    atom[cmx:cmx+3] = np.inner(np.inner(mom,-M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4343                                else:
     4344                                    atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
    43234345                            if atom[cui] == 'A':
    43244346                                Uij = atom[cuij:cuij+6]
     
    43704392                                opNum = G2spc.GetOpNum(item[2],SGData)
    43714393                                mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
    4372                                 atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4394                                if item[2] < 0:
     4395                                    atom[cmx:cmx+3] = np.inner(np.inner(mom,-M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4396                                else:
     4397                                    atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
    43734398                            atom[cs-1] = str(item[2])+'+'
    43744399                            atom[cuij:cuij+6] = item[1]
     
    44264451                            opNum = G2spc.GetOpNum(OprNum,SGData)
    44274452                            mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
    4428                             atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4453                            if Inv:
     4454                                atom[cmx:cmx+3] = np.inner(np.inner(mom,-M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4455                            else:
     4456                                atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
    44294457                        atomOp = atom[cs-1]
    44304458                        newOp = str(((Opr+1)+100*Cent)*(1-2*Inv))+'+'+ \
     
    44624490            cx,ct,cs,ci = data['Drawing']['atomPtrs']
    44634491            cij = ci+2
    4464             cmx = 0
    4465             if 'Mx' in colLabels:
    4466                 cmx = colLabels.index('Mx')
    44674492            SGData = generalData['SGData']
    44684493            SpnFlp = SGData.get('SpnFlp',[])
     
    44884513                                    newAtom[cx:cx+3] = xyz
    44894514                                    newAtom[cs-1] = G2spc.StringOpsProd(oprB,newOp,SGData)
    4490                                     OpN = int(newAtom[cs-1].split('+')[0])
    4491                                     Opr = abs(OpN)%100
    4492                                     M = SGData['SGOps'][Opr-1][0]
    4493                                     if cmx:
    4494                                         opNum = G2spc.GetOpNum(OpN,SGData)
    4495                                         mom = np.inner(np.array(newAtom[cmx:cmx+3]),Bmat)
    4496                                         newAtom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
    44974515                                    atomData.append(newAtom[:cij+9])  #not SS stuff
    44984516            finally:
     
    45094527            atomData = data['Drawing']['Atoms']
    45104528            colLabels = [drawAtoms.GetColLabelValue(c) for c in range(drawAtoms.GetNumberCols())]
    4511             cx,ct,cs,cui = data['Drawing']['atomPtrs']
     4529            cx,ct,cs,ci = data['Drawing']['atomPtrs']
    45124530            cmx = 0
    45134531            if 'Mx' in colLabels:
    45144532                cmx = colLabels.index('Mx')
    4515             cuij = cui+2
     4533            cuij = cs+5
    45164534            generalData = data['General']
    45174535            Amat,Bmat = G2lat.cell2AB(generalData['Cell'][1:7])           
     
    45234541                    atom = atomData[ind]
    45244542                    XYZ = np.array(atom[cx:cx+3])
    4525                     if atom[cui] == 'A':
    4526                         Uij = atom[cuij:cuij+6]
    4527                         result = G2spc.GenAtom(XYZ,SGData,False,Uij,True)
    4528                         for item in result:
    4529                             atom = copy.copy(atomData[ind])
    4530                             atom[cx:cx+3] = item[0]
     4543                    Uij = atom[cuij:cuij+6]
     4544                    result = G2spc.GenAtom(XYZ,SGData,False,Uij,True)
     4545                    for item in result:
     4546                        atom = copy.copy(atomData[ind])
     4547                        atom[cx:cx+3] = item[0]
     4548                        if cmx:
    45314549                            Opr = abs(item[2])%100
    45324550                            M = SGData['SGOps'][Opr-1][0]
    4533                             if cmx:
    4534                                 opNum = G2spc.GetOpNum(item[2],SGData)
    4535                                 mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4551                            opNum = G2spc.GetOpNum(item[2],SGData)
     4552                            mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
     4553                            if item[2] < 0:
     4554                                atom[cmx:cmx+3] = np.inner(np.inner(mom,-M),Amat)*nl.det(M)*SpnFlp[opNum-1]
     4555                            else:
    45364556                                atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
    4537                             atom[cs-1] = str(item[2])+'+' \
    4538                                 +str(item[3][0])+','+str(item[3][1])+','+str(item[3][2])
    4539                             atom[cuij:cuij+6] = item[1]
    4540                             Opp = G2spc.Opposite(item[0])
    4541                             for key in Opp:
    4542                                 if noDuplicate(Opp[key],atomData):
    4543                                     unit = np.array(eval(key))*1.-item[3]
    4544                                     cell = '%d+%d,%d,%d'%(item[2],unit[0],unit[1],unit[2])
    4545                                     atom[cx:cx+3] = Opp[key]
    4546                                     atom[cs-1] = cell
    4547                                     atomData.append(atom[:cuij+9])  #not SS stuff
    4548                     else:
    4549                         result = G2spc.GenAtom(XYZ,SGData,False,Move=True)
     4557                        atom[cs-1] = str(item[2])+'+' \
     4558                            +str(item[3][0])+','+str(item[3][1])+','+str(item[3][2])
     4559                        atom[cuij:cuij+6] = item[1]
     4560                        Opp = G2spc.Opposite(item[0])
     4561                        for key in Opp:
     4562                            if noDuplicate(Opp[key],atomData):
     4563                                unit = np.array(eval(key))*1.-item[3]
     4564                                cell = '%d+%d,%d,%d'%(item[2],unit[0],unit[1],unit[2])
     4565                                atom[cx:cx+3] = Opp[key]
     4566                                atom[cs-1] = cell
     4567                                atomData.append(atom[:cuij+9])  #not SS stuff
    45504568 #                       GSASIIpath.IPyBreak()
    4551                         for item in result:
    4552                             atom = copy.copy(atomData[ind])
    4553                             Opr = abs(item[1])%100
    4554                             M = SGData['SGOps'][Opr-1][0]
    4555                             atom[cx:cx+3] = item[0]
    4556                             if cmx:
    4557                                 opNum = G2spc.GetOpNum(item[1],SGData)
    4558                                 mom = np.inner(np.array(atom[cmx:cmx+3]),Bmat)
    4559                                 atom[cmx:cmx+3] = np.inner(np.inner(mom,M),Amat)*nl.det(M)*SpnFlp[opNum-1]
    4560                             atom[cs-1] = str(item[1])+'+' \
    4561                                 +str(item[2][0])+','+str(item[2][1])+','+str(item[2][2])
    4562                             Opp = G2spc.Opposite(item[0])
    4563                             for key in Opp:
    4564                                 if noDuplicate(Opp[key],atomData):
    4565                                     unit = np.array(eval(key))*1.-item[2]
    4566                                     cell = '%d+%d,%d,%d'%(item[1],unit[0],unit[1],unit[2])
    4567                                     atom[cx:cx+3] = Opp[key]
    4568                                     atom[cs-1] = cell
    4569                                     atomData.append(atom[:cuij+9])  #not SS stuff
    45704569                    data['Drawing']['Atoms'] = atomData
    45714570            finally:
  • trunk/GSASIIplot.py

    r2484 r2486  
    12721272                Ymax = max(Pattern[1][1])
    12731273                if G2frame.plotStyle['sqrtPlot']:
    1274                     Pattern[0]['delOffset'] = .002*Ymax
    1275                     Pattern[0]['refOffset'] = -0.1*Ymax
    1276                     Pattern[0]['refDelt'] = .1*Ymax
     1274                    Pattern[0]['delOffset'] = .002*np.sqrt(Ymax)
     1275                    Pattern[0]['refOffset'] = -0.1*np.sqrt(Ymax)
     1276                    Pattern[0]['refDelt'] = .1*np.sqrt(Ymax)
    12771277                else:
    12781278                    Pattern[0]['delOffset'] = .02*Ymax
     
    16661666                    num = Phases.keys().index(pick)
    16671667                    if num:
    1668                         data[0]['refDelt'] = -(event.ydata-Pattern[0]['refOffset'])/(num*Ymax)
     1668                        data[0]['refDelt'] = -(event.ydata-Pattern[0]['refOffset'])/num
    16691669                    else:       #1st row of refl ticks
    16701670                        data[0]['refOffset'] = event.ydata
     
    17681768                    Pattern.append(G2frame.PatternTree.GetItemText(item))
    17691769                if 'Offset' not in Pattern[0]:     #plot offset data
     1770                    print 'no Offset?'
    17701771                    Ymax = max(Pattern[1][1])
    17711772                    Pattern[0].update({'Offset':[0.0,0.0],'delOffset':0.02*Ymax,'refOffset':-0.1*Ymax,'refDelt':0.1*Ymax,})
     
    19171918                        W = np.where(xye[4]>=0.,np.sqrt(xye[4]),-np.sqrt(-xye[4]))
    19181919                        np.seterr(invalid=olderr['invalid'])
    1919                         D = np.where(xye[5],(Y-Z),0.)-Ymax*Pattern[0]['delOffset']
     1920                        D = np.where(xye[5],(Y-Z),0.)-Pattern[0]['delOffset']
    19201921                    else:
    19211922                        W = xye[4]+offsetY*N*Ymax/100.0
    1922                         D = xye[5]-Ymax*Pattern[0]['delOffset']  #powder background
     1923                        D = xye[5]-Pattern[0]['delOffset']  #powder background
    19231924                elif 'SASD' in plottype:
    19241925                    if G2frame.sqPlot:
     
    20662067                else:
    20672068                    peak = np.array([[peak[4],peak[5]] for peak in peaks])
    2068                 pos = Pattern[0]['refOffset']-pId*Ymax*Pattern[0]['refDelt']*np.ones_like(peak)
     2069                pos = Pattern[0]['refOffset']-pId*Pattern[0]['refDelt']*np.ones_like(peak)
    20692070                if G2frame.plotStyle['qPlot']:
    20702071                    Plot.plot(2*np.pi/peak.T[0],pos,refColors[pId%6]+'|',mew=1,ms=8,picker=3.,label=phase)
     
    36153616                G2frame.VcovColor = 'RdYlGn'
    36163617            dlg.Destroy()
     3618        elif event.key == 'p':
     3619            covFile = open(os.path.splitext(G2frame.GSASprojectfile)[0]+'.cov','w')
     3620            covFile.write(128*'*' + '\n')
     3621            covFile.write('*' + 126*' ' + '*\n')
     3622            covFile.write('*{:^126}*\n'.format('Covariance Matrix'))
     3623            covFile.write('*' + 126*' ' + '*\n')
     3624            covFile.write(128*'*' + '\n\n\n\n')
     3625            llen = len(varyList)
     3626            for start in xrange(0, llen, 8):  # split matrix into batches of 7 columns
     3627                if llen >= start + 8:
     3628                    stop = start + 8
     3629                else:
     3630                    stop = llen
     3631                covFile.write(12*' ' + '\t')
     3632                for idx in xrange(start, stop):
     3633                    covFile.write('{:^12}\t'.format(varyList[idx]))
     3634                covFile.write('\n\n')
     3635                for line in xrange(llen):
     3636                    covFile.write('{:>12}\t'.format(varyList[line]))
     3637                    for idx in xrange(start, stop):
     3638                        covFile.write('{: 12.6f}\t'.format(covArray[line][idx]))
     3639                    covFile.write('\n')
     3640                covFile.write('\n\n\n')
     3641            covFile.close()
    36173642        PlotCovariance(G2frame,Data)
    36183643
     
    36453670        Page.canvas.mpl_connect('motion_notify_event', OnMotion)
    36463671        Page.canvas.mpl_connect('key_press_event', OnPlotKeyPress)
    3647     Page.Choice = ['s: to change colors']
     3672    Page.Choice = ['s: to change colors','p: to save covariance as text file']
    36483673    Page.keyPress = OnPlotKeyPress
    36493674    G2frame.G2plotNB.status.SetFields(['',''])
  • trunk/GSASIIspc.py

    r2483 r2486  
    984984   
    985985def GetOpNum(Opr,SGData):
    986     Inv = SGData['SGInv']
    987986    Nops = len(SGData['SGOps'])
    988987    opNum = abs(Opr)%100
     988    cent = abs(Opr)/100
    989989    if Opr < 0:
    990990        opNum += Nops
    991     cent = abs(Opr)/100
    992     opNum += cent*Nops*Inv
     991    if SGData['SGInv']:
     992        Nops *= 2
     993    opNum += cent*Nops
    993994    return opNum
    994995       
     
    20592060    CSI = [[1,2,3],[1.0,1.0,1.0]]
    20602061    for opr in dupDir:
     2062        if '-1' in siteSym and SpnFlp[len(SpnFlp)/2] < 0:
     2063            return [[0,0,0],[0.,0.,0.]]
    20612064        indx = GetNXUPQsym(opr)
    20622065        if SpnFlp[dupDir[opr]] > 0.:
     
    20642067        else:
    20652068            csi = CSxinel[indx[3]]  #Q
     2069        if not len(csi):
     2070            return [[0,0,0],[0.,0.,0.]]
    20662071        for kcs in [0,1,2]:
    20672072            if csi[0][kcs] == 0 and CSI[0][kcs] != 0:
  • trunk/GSASIIstrMath.py

    r2484 r2486  
    669669    SGT = np.array([ops[1] for ops in SGData['SGOps']])
    670670    Ncen = len(SGData['SGCen'])
     671    Nops = len(SGMT)
    671672    FFtables = calcControls['FFtables']
    672673    BLtables = calcControls['BLtables']
     
    693694        if SGData['SGInv']:
    694695            Gdata = np.hstack((Gdata,-Gdata))       #inversion if any
    695         Gdata = np.repeat(Gdata,Ncen,axis=1)    #dup over cell centering
     696            Nops *= 2
     697        Gdata = np.repeat(Gdata,Ncen,axis=1)        #dup over cell centering
    696698        Gdata = SGData['MagMom'][nxs,:,nxs]*Gdata   #flip vectors according to spin flip
    697699        Gdata = np.inner(Amat,Gdata.T)              #convert back to cart. space MXYZ, Natoms, NOps*Inv*Ncen
     
    766768        FF = np.repeat(refDict['FF']['FF'][iBeg:iFin].T[Tindx].T,len(SGT)*len(TwinLaw),axis=0)
    767769        if 'N' in calcControls[hfx+'histType'] and parmDict[pfx+'isMag']:
    768             MF = refDict['FF']['MF'][iBeg:iFin]   #Nref,Natm
    769             TMcorr = 0.5*0.539*Tcorr[:,0,:]*MF*len(SGMT)/Mdata                              #Nref,Natm
     770            MF = refDict['FF']['MF'][iBeg:iFin].T[Tindx].T   #Nref,Natm
     771#            TMcorr = 0.5*0.539*Tcorr[:,0,:]*MF*len(SGMT)/Mdata     #Nref,Natm
     772            TMcorr = 0.539*Tcorr[:,0,:]*MF/Nops     #Nref,Natm
    770773            if SGData['SGInv']:
    771774                mphase = np.hstack((phase,-phase))
     
    780783            eDotK = np.sum(HM[:,:,nxs,nxs]*Gdata[:,nxs,:,:],axis=0)
    781784            Q = -HM[:,:,nxs,nxs]*eDotK[nxs,:,:,:]+Gdata[:,nxs,:,:] #xyz,Nref,Nop,Natm = BPM in magstrfc.for OK
    782             fam = Q*TMcorr[nxs,:,nxs,:]*SGData['MagMom'][nxs,nxs,:,nxs]*cosm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #ditto
    783             fbm = Q*TMcorr[nxs,:,nxs,:]*SGData['MagMom'][nxs,nxs,:,nxs]*sinm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #ditto
     785            fam = Q*TMcorr[nxs,:,nxs,:]*cosm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #ditto
     786            fbm = Q*TMcorr[nxs,:,nxs,:]*sinm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #ditto
    784787            fams = np.sum(np.sum(fam,axis=-1),axis=-1)                          #xyz,Nref
    785788            fbms = np.sum(np.sum(fbm,axis=-1),axis=-1)                          #ditto
  • trunk/imports/G2phase.py

    r2475 r2486  
    239239            Ptype = 'nuclear'
    240240        elif NPhas[result] in ['2','3']:
    241             Ptype = 'magnetic'
    242             MagDmin = 1.0
     241            Ptype = 'nuclear'
     242#            Ptype = 'magnetic'
     243#            MagDmin = 1.0
    243244        elif NPhas[result] == '4':
    244245            Ptype = 'macromolecular'
     
    261262                    self.warnings += '\nThe GSAS space group was not interpreted(!) and has been set to "P 1".'
    262263                    self.warnings += "Change this in phase's General tab."                       
    263             elif 'SPNFLP' in key:
    264                 SpnFlp = np.array([int(float(s)) for s in EXPphase[key].split()])
    265                 SpnFlp = np.where(SpnFlp==0,1,SpnFlp)
    266                 if SGData['SpGrp'][0] in ['A','B','C','I','R','F']:
    267                     SpnFlp += [1,1,1,1]
    268             elif 'MXDSTR' in key:
    269                 MagDmin = float(EXPphase[key][:10])               
     264#            elif 'SPNFLP' in key:
     265#                SpnFlp = np.array([int(float(s)) for s in EXPphase[key].split()])
     266#                SpnFlp = np.where(SpnFlp==0,1,SpnFlp)
     267#                if SGData['SpGrp'][0] in ['A','B','C','I','R','F']:
     268#                    SpnFlp += [1,1,1,1]
     269#            elif 'MXDSTR' in key:
     270#                MagDmin = float(EXPphase[key][:10])               
    270271            elif 'OD    ' in key:
    271272                SHdata = EXPphase[key].split() # may not have all 9 values
     
    302303                        XYZ = Atom[3:6]
    303304                        Atom[7],Atom[8] = G2spc.SytSym(XYZ,SGData)[:2]
    304                         if Ptype == 'magnetic':
    305                             Atom = Atom[:7]+[0.,0.,0.]+Atom[7:]
     305#                        if Ptype == 'magnetic':
     306#                            Atom = Atom[:7]+[0.,0.,0.]+Atom[7:]
    306307                        Atom.append(ran.randint(0,sys.maxint))
    307308                        Atoms.append(Atom)
Note: See TracChangeset for help on using the changeset viewer.