Changeset 2401


Ignore:
Timestamp:
Jul 29, 2016 3:52:31 PM (5 years ago)
Author:
vondreele
Message:

begin adding magnetism; change space group fortran code
modify tutorial menus

Location:
trunk
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIIO.py

    r2341 r2401  
    10291029            'Name':Name,
    10301030            'Type':'nuclear',
     1031            'Modulated':False,
    10311032            'AtomPtrs':[3,1,7,9],
    10321033            'SGData':SGData,
     
    10531054        }
    10541055    if Super and Super.get('Use',False):
    1055         phaseData['General'].update({'Type':'modulated','Super':True,'SuperSg':Super['ssSymb']})
     1056        phaseData['General'].update({'Modulated':True,'Super':True,'SuperSg':Super['ssSymb']})
    10561057        phaseData['General']['SSGData'] = G2spc.SSpcGroup(SGData,Super['ssSymb'])
    10571058        phaseData['General']['SuperVec'] = [Super['ModVec'],False,Super['maxH']]
  • trunk/GSASIIctrls.py

    r2379 r2401  
    38393839    ['StartingGSASII', 'Starting GSAS.htm', 'Starting GSAS-II'],
    38403840       
     3841    ['LabData', 'Laboratory X.htm', 'Fitting laboratory X-ray powder data for fluoroapatite'],
     3842    ['CWNeutron', 'Neutron CW Powder Data.htm', 'CW Neutron Powder fit for Yttrium-Iron Garnet'],
     3843
    38413844    ['FitPeaks', 'Fit Peaks.htm', 'Fitting individual peaks & autoindexing'],
     3845    ['CFjadarite', 'Charge Flipping in GSAS.htm', '     Charge Flipping structure solution for jadarite'],
     3846    ['CFsucrose', 'Charge Flipping - sucrose.htm','     Charge Flipping structure solution for sucrose'],
    38423847    ['BkgFit', 'FitBkgTut.htm',  'Fitting the Starting Background using Fixed Points'],
    38433848       
    3844     ['CWNeutron', 'Neutron CW Powder Data.htm', 'CW Neutron Powder fit for Yttrium-Iron Garnet'],
    3845     ['LabData', 'Laboratory X.htm', 'Fitting laboratory X-ray powder data for fluoroapatite'],
    38463849    ['CWCombined', 'Combined refinement.htm', 'Combined X-ray/CW-neutron refinement of PbSO4'],
    38473850    ['TOF-CW Joint Refinement', 'TOF combined XN Rietveld refinement in GSAS.htm', 'Combined X-ray/TOF-neutron Rietveld refinement'],
     
    38543857       
    38553858    ['CFXraySingleCrystal', 'CFSingleCrystal.htm', 'Charge Flipping structure solution with Xray single crystal data'],       
    3856     ['CFjadarite', 'Charge Flipping in GSAS.htm', 'Charge Flipping structure solution for jadarite'],
    3857     ['CFsucrose', 'Charge Flipping - sucrose.htm', 'Charge Flipping structure solution for sucrose'],
    38583859    ['TOF Charge Flipping', 'Charge Flipping with TOF single crystal data in GSASII.htm', 'Charge flipping with neutron TOF single crystal data'],
    3859     ['MCsimanneal', 'MCSA in GSAS.htm', 'Monte-Carlo simulated annealing structure'],
     3860    ['MCsimanneal', 'MCSA in GSAS.htm', 'Monte-Carlo simulated annealing structure determination'],
    38603861       
    38613862    ['MerohedralTwins', 'Merohedral twin refinement in GSAS.htm', 'Merohedral twin refinements'],
    38623863
    38633864    ['2DCalibration', 'Calibration of an area detector in GSAS.htm', 'Calibration of an area detector'],
    3864     ['2DIntegration', 'Integration of area detector data in GSAS.htm', 'Integration of area detector data'],
     3865    ['2DIntegration', 'Integration of area detector data in GSAS.htm', '     Integration of area detector data'],
    38653866    ['TOF Calibration', 'Calibration of a TOF powder diffractometer.htm', 'Calibration of a Neutron TOF diffractometer'],
    38663867    ['TOF Single Crystal Refinement', 'TOF single crystal refinement in GSAS.htm', 'Single crystal refinement from TOF data'],
     
    38693870    ['2DTexture', 'Texture analysis of 2D data in GSAS-II.htm', 'Texture analysis of 2D data'],
    38703871             
     3872    ['SAsize', 'Small Angle Size Distribution.htm', 'Small angle x-ray data size distribution (alumina powder)'],
     3873    ['SAfit', 'Fitting Small Angle Scattering Data.htm', '     Fitting small angle x-ray data (alumina powder)'],
    38713874    ['SAimages', 'Small Angle Image Processing.htm', 'Image Processing of small angle x-ray data'],
    3872     ['SAfit', 'Fitting Small Angle Scattering Data.htm', 'Fitting small angle x-ray data (alumina powder)'],
    3873     ['SAsize', 'Small Angle Size Distribution.htm', 'Small angle x-ray data size distribution (alumina powder)'],
    38743875    ['SAseqref', 'Sequential Refinement of Small Angle Scattering Data.htm', 'Sequential refinement with small angle scattering data'],
    38753876   
     
    40354036            dlg.EndModal(wx.ID_OK)
    40364037        dlg = wx.Dialog(self,wx.ID_ANY,
    4037                         'Select a tutorial to view',
     4038                        'Select a tutorial to view. NB: indented ones require prerequisite',
    40384039                        style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
    40394040        pnl = wx.Panel(dlg)
  • trunk/GSASIIpath.py

    r2378 r2401  
    451451        print err
    452452        return False
     453    print ("Files installed at: "+loadpath)
    453454    return True
    454455           
  • trunk/GSASIIphsGUI.py

    r2311 r2401  
    219219        if 'AtomPtrs' not in generalData:
    220220            generalData['AtomPtrs'] = [3,1,7,9]
    221             if generalData['Type'] =='macromolecular':
     221            if generalData['Type'] == 'macromolecular':
    222222                generalData['AtomPtrs'] = [6,4,10,12]
    223         if generalData['Type'] in ['modulated','magnetic',]:
     223            elif generalData['Type'] == 'magnetic':
     224                generalData['AtomPtrs'] = [3,1,10,12]
     225        if generalData['Type'] in ['modulated',]:
     226            generalData['Modulated'] = True
     227            generalData['Type'] = 'nuclear'
    224228            if 'Super' not in generalData:
    225229                generalData['Super'] = 1
     
    229233                generalData['4DmapData'] = mapDefault.copy()
    230234                generalData['4DmapData'].update({'MapType':'Fobs'})
     235        if 'Modulated' not in generalData:
     236            generalData['Modulated'] = False
    231237        if 'HydIds' not in generalData:
    232238            generalData['HydIds'] = {}
     
    316322        if General.GetSizer():
    317323            General.GetSizer().Clear(True)
    318         phaseTypes = ['nuclear','modulated','magnetic','macromolecular','faulted']
     324        phaseTypes = ['nuclear','magnetic','macromolecular','faulted']
    319325        SetupGeneral()
    320326        generalData = data['General']
     
    369375                    generalData['Type'] = TypeTxt.GetValue()
    370376                    pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
    371                     if generalData['Type'] in ['modulated','magnetic']:
    372                         if 'SuperSg' not in generalData:
    373                             generalData['SuperSg'] = SetDefaultSSsymbol()
    374                         generalData['SSGData'] = G2spc.SSpcGroup(generalData['SGData'],generalData['SuperSg'])[1]
    375                         if 'MC/SA' in pages:
    376                             pass
    377 #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
    378                         if 'Layers' in pages:
    379                             pass
    380 #                            G2frame.dataDisplay.DeletePage(pages.index('Layers'))
    381                         if 'Wave Data' not in pages:
    382                             G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    383                             G2frame.dataDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
    384                             Id = wx.NewId()
    385                             TabSelectionIdDict[Id] = 'Wave Data'
    386                         wx.CallAfter(UpdateGeneral)
    387                     elif generalData['Type'] == 'faulted':
     377                    if generalData['Type'] == 'faulted':
    388378                        G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadDIFFaX, id=G2gd.wxID_LOADDIFFAX)
    389379                        G2frame.dataFrame.Bind(wx.EVT_MENU, OnSimulate, id=G2gd.wxID_LAYERSIMULATE)
     
    445435                    msg = 'Space Group Information'
    446436                    G2gd.SGMessageBox(General,msg,text,table).Show()
    447                 if generalData['Type'] in ['modulated',]:
     437                if generalData['Modulated']:
    448438                    generalData['SuperSg'] = SetDefaultSSsymbol()
    449439                    generalData['SSGData'] = G2spc.SSpcGroup(generalData['SGData'],generalData['SuperSg'])[1]
     
    456446                    atom[cx+5] = Mult
    457447                wx.CallAfter(UpdateGeneral)
     448               
     449            def OnModulated(event):
     450                if not len(generalData['AtomTypes']):             #can change only if no atoms!
     451                    pages = [G2frame.dataDisplay.GetPageText(PageNum) for PageNum in range(G2frame.dataDisplay.GetPageCount())]
     452                    if generalData['Type'] in ['nuclear','magnetic']:
     453                        generalData['Modulated'] = modulated.GetValue()
     454                        if generalData['Modulated']:
     455                            if 'SuperSg' not in generalData:
     456                                generalData['SuperSg'] = SetDefaultSSsymbol()
     457                            generalData['SSGData'] = G2spc.SSpcGroup(generalData['SGData'],generalData['SuperSg'])[1]
     458                            if 'Super' not in generalData:
     459                                generalData['Super'] = 1
     460                                generalData['SuperVec'] = [[0,0,.1],False,4]
     461                                generalData['SSGData'] = {}
     462                            if '4DmapData' not in generalData:
     463                                generalData['4DmapData'] = mapDefault.copy()
     464                                generalData['4DmapData'].update({'MapType':'Fobs'})
     465                            if 'MC/SA' in pages:
     466                                pass
     467    #                            G2frame.dataDisplay.DeletePage(pages.index('MC/SA'))   #this crashes!!
     468                            if 'Layers' in pages:
     469                                pass
     470    #                            G2frame.dataDisplay.DeletePage(pages.index('Layers'))
     471                            if 'Wave Data' not in pages:
     472                                G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
     473                                G2frame.dataDisplay.InsertPage(3,G2frame.waveData,'Wave Data')
     474                                Id = wx.NewId()
     475                                TabSelectionIdDict[Id] = 'Wave Data'
     476                        else:
     477                            if 'Wave Data' in pages:
     478                                G2frame.dataDisplay.DeletePage(pages.index('Wave Data'))
     479                        wx.CallAfter(UpdateGeneral)
     480                else:
     481                    G2frame.ErrorDialog('Modulation type change error','Can change modulation only if there are no atoms')
     482                    modulated.SetValue(generalData['Modulated'])               
    458483               
    459484            nameSizer = wx.BoxSizer(wx.HORIZONTAL)
     
    472497            SGTxt.Bind(wx.EVT_TEXT_ENTER,OnSpaceGroup)
    473498            nameSizer.Add(SGTxt,0,WACV)
     499            if generalData['Type'] in ['nuclear','magnetic']:
     500                modulated = wx.CheckBox(General,label='Modulated? ')
     501                modulated.SetValue(generalData['Modulated'])
     502                modulated.Bind(wx.EVT_CHECKBOX,OnModulated)
     503                nameSizer.Add(modulated,0,WACV)           
    474504            return nameSizer
    475505           
     
    684714                denSizer.Add(mattTxt,0,WACV)
    685715            return denSizer,denTxt,mattTxt
     716           
     717        def MagSizer():
     718           
     719            def OnSpinOp(event):
     720                Obj = event.GetEventObject()
     721                isym = Indx[Obj.GetId()]
     722                SGData['SGSpin'][isym] = Obj.GetValue()
     723                wx.CallAfter(UpdateGeneral)                               
     724
     725            SGData = generalData['SGData']           
     726            Indx = {}
     727            MagSym = generalData['SGData']['SpGrp'].split()
     728            magSizer = wx.BoxSizer(wx.VERTICAL)
     729            magSizer.Add(wx.StaticText(General,label=' Magnetic spin operator selection:'),0,WACV)
     730            magSizer.Add(wx.StaticText(General,label='NB: UNDER CONSTRUCTION - DO NOT USE'),0,WACV)
     731            if not len(GenSym):
     732                magSizer.Add(wx.StaticText(General,label=' No spin inversion allowed'),0,WACV)
     733                return magSizer
     734            spinSizer = wx.BoxSizer(wx.HORIZONTAL)
     735            spinColor = ['black','red']
     736            for isym,sym in enumerate(GenSym):
     737                spinSizer.Add(wx.StaticText(General,label='%s: '%(sym.strip())),0,WACV)               
     738                spinOp = wx.ComboBox(General,value=SGData['SGSpin'][isym],choices=spinColor,
     739                    style=wx.CB_READONLY|wx.CB_DROPDOWN)               
     740                Indx[spinOp.GetId()] = isym
     741                spinOp.Bind(wx.EVT_COMBOBOX,OnSpinOp)
     742                spinSizer.Add(spinOp,0,WACV)
     743            MagSym = G2spc.MagSGSym(SGData)
     744            spinSizer.Add(wx.StaticText(General,label=' Magnetic space group: '+MagSym),0,WACV)
     745            magSizer.Add(spinSizer)
     746            return magSizer
    686747           
    687748        def PawleySizer():
     
    11881249        G2G.HorizontalLine(mainSizer,General)
    11891250       
    1190         if generalData['Type'] in ['modulated','magnetic',]:
     1251        if generalData['Type'] == 'magnetic':
     1252            GenSym,GenFlg = G2spc.GetGenSym(generalData['SGData'])
     1253            mainSizer.Add(MagSizer())
     1254            G2G.HorizontalLine(mainSizer,General)
     1255
     1256        if generalData['Modulated']:
    11911257            G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_SINGLEMCSA,False)
    11921258            G2frame.dataFrame.GeneralCalc.Enable(G2gd.wxID_MULTIMCSA,False)
     
    12271293            G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Phases'),text=phaseName)
    12281294        G2frame.PatternTree.SetItemPyData(sub,newPhase)
    1229 #        G2gd.MovePatternTreeToGrid(G2frame,sub) #bring up new phase General tab
    12301295       
    12311296################################################################################
     
    12471312                if Atoms.GetColLabelValue(c) == 'refine':
    12481313                    Type = generalData['Type']
    1249                     if Type in ['nuclear','macromolecular','modulated','faulted',]:
     1314                    if Type in ['nuclear','macromolecular','faulted',]:
    12501315                        choice = ['F - site fraction','X - coordinates','U - thermal parameters']
    12511316                    elif Type in ['magnetic',]:
     
    13981463                                Atoms.SetCellStyle(r,ci,WHITE,False)
    13991464                    SetupGeneral()
     1465                elif Atoms.GetColLabelValue(c) in ['Mx','My','Mz']:
     1466                    pass
    14001467                elif Atoms.GetColLabelValue(c) == 'I/A':            #note use of text color to make it vanish!
    14011468                    if atomData[r][c] == 'I':
     
    16261693                wg.GRID_VALUE_CHOICE+AAchoice,
    16271694                wg.GRID_VALUE_STRING] + Types
     1695        elif generalData['Type'] == 'magnetic':
     1696            colLabels = colLabels[:7]+['Mx','My','Mz']+colLabels[7:]
     1697            Types = Types[:7]+3*[wg.GRID_VALUE_FLOAT+':10,4',]+Types[7:]
    16281698        SGData = data['General']['SGData']
    16291699        G2frame.dataFrame.SetStatusText('')
     
    16681738        Sytsym,Mult = G2spc.SytSym([x,y,z],SGData)
    16691739        if generalData['Type'] == 'macromolecular':
    1670             atomData.append([0,Name,'',Name,El,'',x,y,z,1,Sytsym,Mult,'I',0.10,0,0,0,0,0,0,atId])
     1740            atomData.append([0,Name,'',Name,El,'',x,y,z,1.,Sytsym,Mult,'I',0.10,0,0,0,0,0,0,atId])
    16711741        elif generalData['Type'] in ['nuclear','faulted',]:
    1672             atomData.append([Name,El,'',x,y,z,1,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId])
    1673         elif generalData['Type'] in ['modulated','magnetic',]:
    1674             atomData.append([Name,El,'',x,y,z,1,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId,[],[],
    1675                 {'SS1':{'waveType':'Fourier','Sfrac':[],'Spos':[],'Sadp':[],'Smag':[]}}])
     1742            if generalData['Modulated']:
     1743                atomData.append([Name,El,'',x,y,z,1.,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId,[],[],
     1744                    {'SS1':{'waveType':'Fourier','Sfrac':[],'Spos':[],'Sadp':[],'Smag':[]}}])
     1745            else:
     1746                atomData.append([Name,El,'',x,y,z,1.,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId])
     1747        elif generalData['Type'] == 'magnetic':
     1748            if generalData['Modulated']:
     1749                atomData.append([Name,El,'',x,y,z,1.,0.,0.,0.,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId,[],[],
     1750                    {'SS1':{'waveType':'Fourier','Sfrac':[],'Spos':[],'Sadp':[],'Smag':[]}}])
     1751            else:
     1752                atomData.append([Name,El,'',x,y,z,1.,0.,0.,0.,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId])
     1753           
    16761754        SetupGeneral()
    16771755        data['Drawing']['Atoms'] = []
     
    18581936        generalData = data['General']
    18591937        SGData = generalData['SGData']
    1860         if generalData['Type'] in ['nuclear','modulated','faulted',]:
     1938        if generalData['Type'] in ['nuclear','faulted',]:
    18611939            if oldatom:
    18621940                opr = oldatom[5]
     
    18711949                    ['',]+[[255,255,255],]+atom[9:]+[[],[]]][0]
    18721950            ct,cs = [1,8]         #type & color
     1951        elif  generalData['Type'] == 'magnetic':
     1952            atomInfo = [atom[:2]+atom[3:6]+atom[7:10]+['1',]+['vdW balls',]+
     1953                ['',]+[[255,255,255],]+atom[12:]+[[],[]]][0]
     1954            ct,cs = [1,11]         #type & color
    18731955        elif generalData['Type'] == 'macromolecular':
    18741956            try:
     
    18941976            atomData.insert(indx,[0,Name,'',Name,El,'',x,y,z,1,Sytsym,Mult,'I',0.10,0,0,0,0,0,0,atId])
    18951977        elif generalData['Type'] in ['nuclear','faulted',]:
    1896             atomData.insert(indx,[Name,El,'',x,y,z,1,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId])
    1897         elif generalData['Type'] in ['modulated','magnetic']:
    1898             atomData.insert(indx,[Name,El,'',x,y,z,1,Sytsym,Mult,0,'I',0.01,0,0,0,0,0,0,atId,[],[],
    1899                 {'SS1':{'waveType':'Fourier','Sfrac':[],'Spos':[],'Sadp':[],'Smag':[]}}])
    1900         SetupGeneral()
     1978            if generalData['Modulated']:
     1979                atomData.insert(indx,[Name,El,'',x,y,z,1,Sytsym,Mult,0,'I',0.01,0,0,0,0,0,0,atId,[],[],
     1980                    {'SS1':{'waveType':'Fourier','Sfrac':[],'Spos':[],'Sadp':[],'Smag':[]}}])
     1981            else:
     1982                atomData.insert(indx,[Name,El,'',x,y,z,1,Sytsym,Mult,'I',0.01,0,0,0,0,0,0,atId])
     1983            SetupGeneral()
    19011984        data['Drawing']['Atoms'] = []
    19021985        UpdateDrawAtoms()
     
    35933676            drawingData['showRigidBodies'] = True
    35943677        cx,ct,cs,ci = [0,0,0,0]
    3595         if generalData['Type'] in ['nuclear','modulated','faulted',]:
     3678        if generalData['Type'] in ['nuclear','faulted',]:
    35963679            cx,ct,cs,ci = [2,1,6,17]         #x, type, style & index
    35973680        elif generalData['Type'] == 'macromolecular':
    35983681            cx,ct,cs,ci = [5,4,9,20]         #x, type, style & index
    35993682        elif generalData['Type'] == 'magnetic':
    3600             cx,ct,cs,ci = [2,1,6,20]         #x, type, style & index
    3601 #        elif generalData['Type'] == 'modulated':
    3602 #           ?????   for future
     3683            cx,ct,cs,ci = [2,1,9,20]         #x, type, style & index
    36033684        drawingData['atomPtrs'] = [cx,ct,cs,ci]
    36043685        if not drawingData.get('Atoms'):
     
    38673948            labelChoice = [' ','type','name','number','residue','1-letter','chain']
    38683949            Types[9] = wg.GRID_VALUE_CHOICE+": ,type,name,number,residue,1-letter,chain"
     3950        elif generalData['Type'] == 'magnetic':
     3951            colLabels = colLabels[:5]+['Mx','My','Mz']+colLabels[5:]
     3952            Types = Types[:5]+3*[wg.GRID_VALUE_FLOAT+':10,4',]+Types[5:]
    38693953        table = []
    38703954        rowLabels = []
     
    67406824            rowLabels = []
    67416825            for i in range(len(PawleyPeaks)): rowLabels.append(str(i))
    6742             if generalData['Type'] in ['modulated','magnetic',]:
     6826            if generalData['Modulated']:
    67436827                colLabels = ['h','k','l','m','mul','d','refine','Fsq(hkl)','sig(Fsq)']
    67446828                Types = 5*[wg.GRID_VALUE_LONG,]+[wg.GRID_VALUE_FLOAT+':10,4',wg.GRID_VALUE_BOOL,]+ \
     
    67716855        PawleyPeaks = []
    67726856        HKLd = np.array(G2lat.GenHLaue(dmin,SGData,A))
    6773         if generalData['Type'] in ['modulated','magnetic',]:
     6857        if generalData['Modulated']:
    67746858            Vec,x,maxH = generalData['SuperVec']
    67756859            SSGData = G2spc.SSpcGroup(SGData,generalData['SuperSg'])[1]
     
    68106894        generalData = data['General']
    68116895        im = 0
    6812         if generalData['Type'] in ['modulated','magnetic',]:
     6896        if generalData['Modulated']:
    68136897            im = 1
    68146898        HistoNames = filter(lambda a:Histograms[a]['Use']==True,Histograms.keys())
     
    68686952            PatternId,'Reflection Lists'))[PhaseName]['RefList']
    68696953        im = 0
    6870         if data['General']['Type'] in ['modulated','magnetic',]:
     6954        if data['General']['Modulated']:
    68716955            im = 1
    68726956        Inv = data['General']['SGData']['SGInv']
     
    70967180            pgbar.Destroy()
    70977181        else:
    7098             if generalData['Type'] in ['modulated',]:
     7182            if generalData['Modulated']:
    70997183                dim = '4D '
    71007184                G2mth.Fourier4DMap(data,ReflData)
     
    73547438            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.LayerData)
    73557439            UpdateLayerData()
    7356         elif text == 'Wave Data' and data['General']['Type'] in ['modulated','magnetic']:
     7440        elif text == 'Wave Data' and data['General']['Modulated']:
    73577441            G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.WavesData)
    73587442            UpdateWavesData()
     
    74357519            G2frame.dataFrame.Bind(wx.EVT_MENU, OnReImport, id=id)
    74367520        # Wave Data
    7437         if data['General']['Type'] in ['modulated','magnetic']:
     7521        if data['General']['Modulated']:
    74387522            FillSelectPageMenu(TabSelectionIdDict, G2frame.dataFrame.WavesData)
    74397523            G2frame.dataFrame.Bind(wx.EVT_MENU, OnWaveVary, id=G2gd.wxID_WAVEVARY)
     
    75117595    if 'dict' in str(type(data['MCSA']['Results'])):
    75127596        data['MCSA']['Results'] = []
     7597    if 'Modulated' not in data['General']:
     7598        data['General']['Modulated'] = False
     7599    if 'modulated' in data['General']['Type']:
     7600        data['General']['Modulated'] = True
     7601        data['General']['Type'] = 'nuclear'
     7602       
    75137603#end patch   
    75147604
     
    75367626    G2frame.dataDisplay.AddPage(Atoms,'Atoms')
    75377627    Pages.append('Atoms')
    7538     if data['General']['Type'] in ['modulated','magnetic']:
     7628    if data['General']['Modulated']:
    75397629        G2frame.waveData = wx.ScrolledWindow(G2frame.dataDisplay)
    75407630        G2frame.dataDisplay.AddPage(G2frame.waveData,'Wave Data')
     
    75517641    G2frame.dataDisplay.AddPage(drawAtoms,'Draw Atoms')
    75527642    Pages.append('Draw Atoms')
    7553     if data['General']['Type'] not in ['modulated','magnetic','faulted',]:
     7643    if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
    75547644        RigidBodies = wx.ScrolledWindow(G2frame.dataDisplay)
    75557645        G2frame.dataDisplay.AddPage(RigidBodies,'RB Models')
     
    75597649    G2frame.dataDisplay.AddPage(MapPeaks,'Map peaks')
    75607650    Pages.append('Map peaks')
    7561     if data['General']['Type'] not in ['modulated','magnetic','faulted',]:
     7651    if data['General']['Type'] not in ['faulted',] and not data['General']['Modulated']:
    75627652        G2frame.MCSA = wx.ScrolledWindow(G2frame.dataDisplay)
    75637653        G2frame.dataDisplay.AddPage(G2frame.MCSA,'MC/SA')
  • trunk/GSASIIplot.py

    r2375 r2401  
    47514751    B4mat = np.concatenate((np.concatenate((Bmat,[[0],[0],[0]]),axis=1),[[0,0,0,1],]),axis=0)
    47524752    SGData = generalData['SGData']
    4753     if generalData['Type'] in ['modulated','magnetic']:
     4753    if generalData['Modulated']:
    47544754        SSGData = generalData['SSGData']
    47554755    Mydir = generalData['Mydir']
     
    49434943            SetPeakRoll(dirDict[key])
    49444944            SetMapPeaksText(mapPeaks)
    4945         elif key in ['M',]and generalData['Type'] in ['modulated','magnetic']:  #make a movie file
     4945        elif key in ['M',]and generalData['Modulated']:  #make a movie file
    49464946            G2frame.tau = 0.
    49474947            for i in range(10):
     
    49544954                    Fade += 1
    49554955                Draw('key down',Fade)
    4956         elif key in ['+','-','=','0'] and generalData['Type'] in ['modulated','magnetic']:
     4956        elif key in ['+','-','=','0'] and generalData['Modulated']:
    49574957            if keyBox:
    49584958                OnKeyPressed(event)
     
    49684968        except AttributeError:       #if from OnKeyBox above
    49694969            key = str(event.key).upper()
    4970         if key in ['+','-','=','0'] and generalData['Type'] in ['modulated','magnetic']:
     4970        if key in ['+','-','=','0'] and generalData['Modulated']:
    49714971            if key == '0':
    49724972                G2frame.tau = 0.
     
    57945794    else:
    57955795        choice = [' save as/key:','jpeg','tiff','bmp','c: center on 1/2,1/2,1/2','n: next','p: previous']
    5796     if generalData['Type'] in ['modulated','magnetic',] and len(drawAtoms):
     5796    if generalData['Modulated'] and len(drawAtoms):
    57975797        choice += ['+: increase tau','-: decrease tau','0: set tau = 0']    #add 'm: make modulation movie'
    57985798
  • trunk/GSASIIspc.py

    r2367 r2401  
    9393        SGData['SGCen'] = np.array(([0,0,0],[1./3.,2./3.,2./3.],[2./3.,1./3.,1./3.]))
    9494    SGData['SGOps'] = []
     95    SGData['SGGen'] = []
     96    SGData['SGSpin'] = []
    9597    for i in range(SGInfo[5]):
    9698        Mat = np.array(SGInfo[6][i])
    9799        Trns = np.array(SGInfo[7][i])
    98100        SGData['SGOps'].append([Mat,Trns])
     101        SGData['SGGen'].append(int(SGInfo[8][i]))
     102        SGData['SGSpin'].append('black')
    99103    if SGData['SGLaue'] in '-1':
    100104        SGData['SGSys'] = SysSym[0]
     
    115119    SGData['SGPolax'] = SGpolar(SGData)
    116120    SGData['SGPtGrp'],SGData['SSGKl'] = SGPtGroup(SGData)
    117     return SGInfo[8],SGData
     121    return SGInfo[-1],SGData
    118122
    119123def SGErrors(IErr):
     
    417421    for l in SGPrint(A):
    418422        print l
     423       
     424def GetGenSym(SGData):
     425    '''
     426    Get the space group generator symbols
     427    :param SGData: from :func:`SpcGroup`
     428    LaueSym = ('-1','2/m','mmm','4/m','4/mmm','3R','3mR','3','3m1','31m','6/m','6/mmm','m3','m3m')
     429    LattSym = ('P','A','B','C','I','F','R')
     430    UniqSym = ('','','a','b','c','',)
     431   
     432    '''
     433    if SGData['SGInv']:
     434        if SGData['SGLaue'] in ['-1','2/m','mmm']:
     435            Ibar = 7
     436        elif SGData['SGLaue'] in ['4/m','4/mmm']:
     437            Ibar = 1
     438        elif SGData['SGLaue'] in ['3R','3mR','3','3m1','31m','6/m','6/mmm']:
     439            Ibar = 15 #8+4+2+1
     440        else:
     441            Ibar = 4
     442        Ibarx = Ibar&14
     443    else:
     444        Ibarx = 8
     445        if SGData['SGLaue'] in ['-1','2/m','mmm','m3','m3m']:
     446            Ibarx = 0
     447    moregen = []
     448    for gen in SGData['SGGen']:
     449        if SGData['SGLaue'] in ['m3','m3m']:
     450            if gen in [1,2,4]: gen = 4
     451            elif gen < 7: gen = 0
     452        elif SGData['SGLaue'] in ['4/m','4/mmm','3R','3mR','3','3m1','31m','6/m','6/mmm']:
     453            if gen == 2: gen = 4
     454            elif gen in [3,5]: gen = 3
     455            elif gen == 6:
     456                if SGData['SGLaue'] in ['4/m','4/mmm']: gen = 128
     457                else: gen = 16
     458            elif not SGData['SGInv'] and gen == 12: gen = 8
     459            elif not SGData['SGInv'] and SGData['SGLaue'] in ['3','3m1','31m','6/m','6/mmm'] and gen == 1 : gen = 24
     460        if gen == 99:
     461            if SGData['SGLaue'] in ['3m1','31m','6/m','6/mmm']: gen = 3
     462            elif SGData['SGLaue'] == 'm3m': gen = 12
     463            else: gen = 8
     464        elif gen == 98:
     465            if SGData['SGLaue'] in ['3m1','31m','6/m','6/mmm']: gen = 4
     466            else: gen = 8
     467        elif not SGData['SGInv'] and gen == 23 and SGData['SGLaue'] in ['m3','m3m']: gen = 24
     468        elif gen >= 16 and gen != 128:
     469            if not SGData['SGInv']: gen = 31
     470            else: gen = gen^Ibarx
     471        if SGData['SGInv']:
     472            if gen < 128:
     473                moregen.append(gen^Ibar)
     474            else:
     475                moregen.append(1)
     476    SGData['SGGen'] += moregen
     477    OprNames = [GetOprPtrName(str(irtx))[1] for irtx in PackRot(SGData['SGOps'])]
     478    if SGData['SGInv']:
     479        OprNames += [GetOprPtrName(str(-irtx))[1] for irtx in PackRot(SGData['SGOps'])]
     480    Nsyms = len(SGData['SGOps'])
     481    if SGData['SGInv']: Nsyms *= 2
     482    UsymOp = []
     483    OprFlg = []   
     484    if Nsyms in [1,3]: NunqOp = 0       #Triclinic acentric OR trigonal 3
     485    elif Nsyms == 2:                    #Centric triclinic or acentric momoclinic
     486        NunqOp = 1
     487        UsymOp.append(OprNames[1])
     488        OprFlg.append(SGData['SGGen'][1])
     489    elif Nsyms == 4:                    #Point symmetry 2/m, 222, 22m, or 4
     490        if '4z' in OprNames[1]:          #Point symmetry 4 or -4
     491            NunqOp = 1
     492            UsymOp.append(OprNames[1])
     493            OprFlg.append(SGData['SGGen'][1])
     494        elif not SGData['SGInv']:       #Acentric Orthorhombic
     495            if 'm' in OprNames[1:4]:    #22m, 2m2 or m22
     496                NunqOp = 2
     497                if '2' in OprNames[1]:      #Acentric orthorhombic, 2mm
     498                    UsymOp.append(OprNames[2])
     499                    OprFlg.append(SGData['SGGen'][2])
     500                    UsymOp.append(OprNames[3])
     501                    OprFlg.append(SGData['SGGen'][3])
     502                elif '2' in OprNames[2]:    #Acentric orthorhombic, m2m
     503                    UsymOp.append(OprNames[1])
     504                    OprFlg.append(SGData['SGGen'][1])
     505                    UsymOp.append(OprNames[3])
     506                    OprFlg.append(SGData['SGGen'][3])
     507                else:                       #Acentric orthorhombic, mm2
     508                    UsymOp.append(OprNames[1])
     509                    OprFlg.append(SGData['SGGen'][1])
     510                    UsymOp.append(OprNames[2])
     511                    OprFlg.append(SGData['SGGen'][2])
     512            else:                           #Acentric orthorhombic, 222
     513                NunqOp = -3
     514                SGData['SGGen'][1:] = [4,2,1]
     515                UsymOp.append(OprNames[1])
     516                OprFlg.append(SGData['SGGen'][1])
     517                UsymOp.append(OprNames[2])
     518                OprFlg.append(SGData['SGGen'][2])
     519                UsymOp.append(OprNames[3])
     520                OprFlg.append(SGData['SGGen'][3])
     521        else:                               #Centric Monoclinic
     522            NunqOp = 2
     523            UsymOp.append(OprNames[1])
     524            OprFlg.append(SGData['SGGen'][1])
     525            UsymOp.append(OprNames[3])
     526            OprFlg.append(SGData['SGGen'][3])
     527    elif Nsyms == 6:                    #Point symmetry 32, 3m or 6
     528            NunqOp = 1
     529            if '6' in OprNames[1]:      #Hexagonal 6/m Laue symmetry
     530                UsymOp.append(OprNames[1])
     531                OprFlg.append(SGData['SGGen'][1])
     532            else:                       #Trigonal
     533                UsymOp.append(OprNames[4])
     534                OprFlg.append(SGData['SGGen'][3])
     535                if '2100' in OprNames[1]: UsymOp[-1] = ' 2100 '
     536    elif Nsyms == 8:                    #Point symmetry mmm, 4/m, or 422, etc
     537        if '4' in OprNames[1]:           #Tetragonal
     538            NunqOp = 2
     539            if SGData['SGInv']:         #4/m
     540                UsymOp.append(OprNames[1])
     541                OprFlg.append(SGData['SGGen'][1])
     542                UsymOp.append(OprNames[6])
     543                OprFlg.append(SGData['SGGen'][6])
     544            else:
     545                if 'x' in OprNames[4]:      #4mm type group
     546                    UsymOp.append(OprNames[4])
     547                    OprFlg.append(5)
     548                    UsymOp.append(OprNames[7])
     549                    OprFlg.append(7)
     550                else:                       #-42m, -4m2, and 422 type groups
     551                    UsymOp.append(OprNames[5])
     552                    OprFlg.append(7)
     553                    UsymOp.append(OprNames[6])
     554                    OprFlg.append(18)
     555        else:                               #Orthorhombic, mmm
     556            NunqOp = 3
     557            UsymOp.append(OprNames[1])
     558            OprFlg.append(SGData['SGGen'][1])
     559            UsymOp.append(OprNames[2])
     560            OprFlg.append(SGData['SGGen'][2])
     561            UsymOp.append(OprNames[7])
     562            OprFlg.append(SGData['SGGen'][7])
     563    elif Nsyms == 12 and '3' in OprNames[1]:        #Trigonal
     564        NunqOp = 2
     565        UsymOp.append(OprNames[3])
     566        OprFlg.append(SGData['SGGen'][3])
     567        UsymOp.append(OprNames[9])
     568        OprFlg.append(SGData['SGGen'][9])
     569    elif Nsyms == 12 and '6' in OprNames[1]:        #Hexagonal
     570        NunqOp = 2
     571        if 'mz' in OprNames[9]:                     #6/m
     572            UsymOp.append(OprNames[1])
     573            OprFlg.append(SGData['SGGen'][1])
     574            UsymOp.append(OprNames[6])
     575            OprFlg.append(SGData['SGGen'][6])
     576        else:                                       #6mm, -62m, -6m2 or 622
     577            UsymOp.append(OprNames[6])
     578            OprFlg.append(17)
     579            if 'm' in OprNames[1]: OprFlg[-1] = 20
     580            UsymOp.append(OprNames[7])
     581            OprFlg.append(23)
     582    elif Nsyms in [16,24]:
     583        if '3' in OprNames[1]:
     584            NunqOp = 1
     585            UsymOp.append('')
     586            OprFlg.append(SGData['SGGen'][3])
     587            for i in range(Nsyms):
     588                if 'mx' in OprNames[i]:
     589                    UsymOp[-1] = OprNames[i]
     590                elif 'm11' in OprNames[i]:
     591                    UsymOp[-1] = OprNames[i]
     592                elif '211' in OprNames[i]:
     593                    UsymOp[-1] = OprNames[i]
     594                    OprFlg[-1] = 24
     595        else:                                     #4/mmm or 6/mmm
     596            NunqOp = 3
     597            UsymOp.append('  mz  ')
     598            OprFlg.append(1)
     599            if '4' in OprNames[1]:                  #4/mmm
     600                UsymOp.append('  mx  ')
     601                OprFlg.append(19)
     602                UsymOp.append(' m110 ')
     603                OprFlg.append(21)
     604            else:                                   #6/mmm
     605                UsymOp.append(' m110 ')
     606                OprFlg.append(3)
     607                UsymOp.append(' m+-0 ')
     608                OprFlg.append(7)
     609    else:                                           #System is cubic
     610        if Nsyms == 48:
     611            NunqOp = 2
     612            UsymOp.append('  mx  ')
     613            OprFlg.append(3)
     614            UsymOp.append(' m110 ')
     615            OprFlg.append(23)
     616        else:
     617            NunqOp = 0
     618    ncv = len(SGData['SGCen'])
     619    if ncv > 1:
     620        for icv in range(ncv):
     621            if icv:
     622                if SGData['SGCen'][icv][0] == 0.5:
     623                    if SGData['SGCen'][icv][1] == 0.5:
     624                        if SGData['SGCen'][icv][2] == 0.5:
     625                            UsymOp.append(' Icen ')
     626                        else:
     627                            UsymOp.append(' Ccen ')
     628                    else:
     629                        UsymOp.append(' Bcen ')
     630                elif SGData['SGCen'][icv][1] == 0.5:
     631                    UsymOp.append(' Acen ')
     632                else:
     633                    UsymOp.append(' Rcen ')
     634    return UsymOp,OprFlg
     635   
     636def MagSGSym(SGData):
     637    SGLaue = SGData['SGLaue']
     638    SpnFlp = SGData['SGSpin']
     639    if not len(SpnFlp):
     640        return SGData['SpGrp']
     641    print SGData['SpGrp'],': ',SGData['SGGen'],SpnFlp
     642    magSym = SGData['SpGrp'].split()
     643    if len(SpnFlp) == 1:
     644        if 'red' == SpnFlp[-1]:
     645            magSym[1] += "'"
     646        return ' '.join(magSym)
     647                   
     648       
     649    return ' '.join(magSym)
    419650       
    420651################################################################################
     
    20232254    return result[0]
    20242255       
     2256def PackRot(SGOps):
     2257    IRT = []
     2258    for ops in SGOps:
     2259        M = ops[0]
     2260        irt = 0
     2261        for j in range(2,-1,-1):
     2262            for k in range(2,-1,-1):
     2263                irt *= 3
     2264                irt += M[k][j]
     2265        IRT.append(int(irt))
     2266    return IRT
     2267       
    20252268def SytSym(XYZ,SGData):
    20262269    '''
     
    20352278
    20362279    '''
    2037     def PackRot(SGOps):
    2038         IRT = []
    2039         for ops in SGOps:
    2040             M = ops[0]
    2041             irt = 0
    2042             for j in range(2,-1,-1):
    2043                 for k in range(2,-1,-1):
    2044                     irt *= 3
    2045                     irt += M[k][j]
    2046             IRT.append(int(irt))
    2047         return IRT
    2048        
    20492280    SymName = ''
    20502281    Mult = 1
  • trunk/GSASIIstrIO.py

    r2245 r2401  
    890890            line = ' res no residue chain'+line
    891891        print >>pFile,line
    892         if General['Type'] in ['nuclear','modulated','magnetic','faulted',]:
     892        if General['Type'] in ['nuclear','magnetic','faulted',]:
    893893            print >>pFile,135*'-'
    894894            for i,at in enumerate(Atoms):
     
    10761076        SSGtext = []    #no superstructure
    10771077        im = 0
    1078         if General['Type'] in ['modulated','magnetic']:
     1078        if General['Modulated']:
    10791079            im = 1      #refl offset
    10801080            Vec,vRef,maxH = General['SuperVec']
     
    11631163                                    eqv[1] /= coef
    11641164                                G2mv.StoreEquivalence(name,equiv[1:])
    1165                 if General['Type'] in ['modulated','magnetic']:
     1165                if General['Modulated']:
    11661166                    AtomSS = at[-1]['SS1']
    11671167                    waveType = AtomSS['waveType']
     
    12541254                PrintRBObjects(resRBData,vecRBData)
    12551255                PrintAtoms(General,Atoms)
    1256                 if General['Type'] in ['modulated','magnetic']:
     1256                if General['Modulated']:
    12571257                    PrintWaves(General,Atoms)
    12581258                print >>pFile,'\n Unit cell: a = %.5f'%(cell[1]),' b = %.5f'%(cell[2]),' c = %.5f'%(cell[3]), \
     
    18371837            print >>pFile,sigstr
    18381838        ik = 6  #for Pawley stuff below
    1839         if General['Type'] in ['modulated','magnetic']:
     1839        if General['Modulated']:
    18401840            ik = 7
    18411841            Vec,vRef,maxH = General['SuperVec']
     
    19091909                ind = General['AtomTypes'].index(at[ct])
    19101910                General['Mass'] += General['AtomMass'][ind]*at[cx+3]*at[cx+5]
    1911                 if General['Type'] in ['modulated','magnetic']:
     1911                if General['Modulated']:
    19121912                    AtomSS = at[-1]['SS1']
    19131913                    waveType = AtomSS['waveType']
     
    19411941                   
    19421942            PrintAtomsAndSig(General,Atoms,atomsSig)
    1943             if General['Type'] in ['modulated','magnetic']:
     1943            if General['Modulated']:
    19441944                PrintWavesAndSig(General,Atoms,wavesSig)
    19451945           
     
    20802080        cell = Phases[phase]['General']['Cell'][1:7]
    20812081        A = G2lat.cell2A(cell)
    2082         if Phases[phase]['General']['Type'] in ['modulated','magnetic']:
     2082        if Phases[phase]['General']['Modulated']:
    20832083            SSGData = Phases[phase]['General']['SSGData']
    20842084            Vec,x,maxH = Phases[phase]['General']['SuperVec']
     
    21952195                    Uniq = []
    21962196                    Phi = []
    2197                     if Phases[phase]['General']['Type'] in ['modulated','magnetic']:
     2197                    if Phases[phase]['General']['Modulated']:
    21982198                        ifSuper = True
    21992199                        HKLd = np.array(G2lat.GenSSHLaue(dmin,SGData,SSGData,Vec,maxH,A))
  • trunk/GSASIIstrMath.py

    r2240 r2401  
    31153115                Phase = Phases[phase]
    31163116                im = 0
    3117                 if Phase['General']['Type'] in ['modulated','magnetic']:
     3117                if Phase['General']['Modulated']:
    31183118                    im = 1
    31193119                pId = Phase['pId']
     
    32513251        SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
    32523252        im = 0
    3253         if Phase['General']['Type'] in ['modulated','magnetic']:
     3253        if Phase['General']['Modulated']:
    32543254            SSGData = Phase['General']['SSGData']
    32553255            SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
     
    34303430        SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
    34313431        im = 0
    3432         if Phase['General']['Type'] in ['modulated','magnetic']:
     3432        if Phase['General']['Modulated']:
    34333433            SSGData = Phase['General']['SSGData']
    34343434            SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
     
    36883688    SGData = Phase['General']['SGData']
    36893689    im = 0
    3690     if Phase['General']['Type'] in ['modulated','magnetic']:
     3690    if Phase['General']['Modulated']:
    36913691        SSGData = Phase['General']['SSGData']
    36923692        SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
     
    39793979            if parmDict[phfx+'Scale'] < 0.:
    39803980                parmDict[phfx+'Scale'] = .001               
    3981             if Phase['General']['Type'] in ['modulated','magnetic']:
     3981            if Phase['General']['Modulated']:
    39823982                SSGData = Phase['General']['SSGData']
    39833983                SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
  • trunk/fsource/pyspg.for

    r341 r2401  
    22
    33      SUBROUTINE SGFORPY(SPG,LAUE,SGINV,SGLATT,SGUNIQ,SGPOL,
    4      1  SGNOPS,SGMTRX,SGTRNS,IERR)
     4     1  SGNOPS,SGMTRX,SGTRNS,SGGEN,IERR)
    55Cf2py intent(in)  SPG
    66Cf2py intent(out) LAUE
     
    1212Cf2py intent(out) SGMTRX
    1313Cf2py intent(out) SGTRNS
     14Cf2py intent(out) SGGEN
    1415Cf2py intent(out) IERR
    1516
    1617      CHARACTER*(20) SPG
    1718      INTEGER*4     LAUE,SGINV,SGLATT,SGUNIQ,SGNOPS,IERR,SGNCEN
    18       REAL*4        SGMTRX(24,3,3),SGTRNS(24,3)
     19      REAL*4        SGMTRX(24,3,3),SGTRNS(24,3),SGGEN(24)
    1920      REAL*4        RT(5,4,25),CEN(3,4)
    2021      INTEGER*4     JRT(3,5,24)
     
    3031          END DO
    3132        END DO
     33        SGGEN(K) = JRT(3,5,K)
    3234      END DO
    3335      RETURN
  • trunk/imports/G2phase.py

    r2116 r2401  
    260260                    self.warnings += '\nThe GSAS space group was not interpreted(!) and has been set to "P 1".'
    261261                    self.warnings += "Change this in phase's General tab."                       
     262            elif 'SPNFLP' in key:
     263                spin = {'1':'black','-1':'red'}
     264                SpnFlp = [spin[s.strip()] for s in EXPphase[key].split()]               
    262265            elif 'OD    ' in key:
    263266                SHdata = EXPphase[key].split() # may not have all 9 values
     
    276279                shNcof = int(SHvals[1])
    277280        Atoms = []
    278         if Ptype == 'nuclear':
     281        if Ptype in ['nuclear','magnetic',]:
    279282            for key in keyList:
    280283                if 'AT' in key:
     
    296299                        Atom.append(ran.randint(0,sys.maxint))
    297300                        Atoms.append(Atom)
     301                    elif key[11:] == 'M' and key[6:8] == 'AT':
     302                        S = EXPphase[key]
     303                        Mag = [float(S[:10]),float(S[10:20]),float(S[20:30])]
     304                        Atoms[-1] = Atoms[-1][:7]+Mag+Atoms[-1][7:]
    298305        elif Ptype == 'macromolecular':
    299306            for key in keyList:
     
    334341        if general['Type'] =='macromolecular':
    335342            general['AtomPtrs'] = [6,4,10,12]
    336         else:
     343        elif general['Type'] =='magnetic':
     344            general['AtomPtrs'] = [3,1,10,12]
     345            general['SGData']['SGSpin'] = SpnFlp   
     346        else:   #nuclear
    337347            general['AtomPtrs'] = [3,1,7,9]   
    338348        general['SH Texture'] = textureData
     
    440450                if nqi:
    441451                    raise self.ImportException("Supersymmetry too high; GSAS-II limited to (3+1) supersymmetry")           
    442                 Type = 'modulated'
    443452                vec = S.split()[1:]
    444453                SuperVec = [[float(vec[i]) for i in range(3)],False,4]
     
    549558        Phase = G2IO.SetNewPhase(Name=Title,SGData=SGData,cell=cell+[Volume,])
    550559        Phase['General']['Type'] = Type
     560        Phase['General']['Modulated'] = True
    551561        Phase['General']['Super'] = nqi
    552562        Phase['General']['SuperVec'] = SuperVec
Note: See TracChangeset for help on using the changeset viewer.