Changeset 5043


Ignore:
Timestamp:
Oct 7, 2021 8:50:26 AM (2 years ago)
Author:
vondreele
Message:

Add ISODISTORT menu option to RMC menu; active only for PDFfit (under construction)
More additions for PDFfit
fix split --> rsplit in G2phase_CIF importer

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/GSASIIconstrGUI.py

    r5040 r5043  
    39193919                value = '?'
    39203920            subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
    3921             #GSASIIpath.IPyBreak()
    39223921    # ISODISTORT occupancy modes
    39233922    if 'G2OccVarList' in ISO:

  • trunk/GSASIIdataGUI.py

    r5042 r5043  
    64356435        #Phase / fullrmc & RMCprofile (Reverse Monte Carlo method) tab
    64366436        G2G.Define_wxId('wxID_SETUPRMC','wxID_RUNRMC','wxID_VIEWRMC',
    6437                             'wxID_STOPRMC')       
     6437                            'wxID_STOPRMC', 'wxID_ISODISTORT')       
    64386438        self.FRMCMenu = wx.MenuBar()
    64396439        self.PrefillDataMenu(self.FRMCMenu)
    … …  
    64456445        self.FRMCDataEdit.Append(G2G.wxID_STOPRMC,'Stop run','Stop fullrmc run')
    64466446        self.FRMCDataEdit.Append(G2G.wxID_VIEWRMC,'Plot','View fullrmc or RMCprofile results')
     6447        self.FRMCDataEdit.Append(G2G.wxID_ISODISTORT,'Run ISODISTORT','Run ISODISTORT for PDFfit constraints')
    64476448        self.PostfillDataMenu()
    64486449       

  • trunk/GSASIIddataGUI.py

    r5029 r5043  
    246246            if key in fixedVars: selected.append(i)
    247247        dlg = G2G.G2MultiChoiceDialog(G2frame, 'Choose phase vars to fix for this histogram only',
    248                                       'Choose items to edit', phaseKeys,selected=selected)
     248            'Choose items to edit', phaseKeys,selected=selected)
    249249        if dlg.ShowModal() == wx.ID_OK:
    250250            sel = dlg.GetSelections()
    … …  
    922922        bottomSizer.Add(useBox,0,wx.TOP|wx.BOTTOM|wx.LEFT,5)
    923923        if G2frame.testSeqRefineMode() and not UseList[G2frame.hist]['LeBail']:
    924             bottomSizer.Add(wx.StaticText(DData,label='     Sequential Refinemment Options'))
     924            bottomSizer.Add(wx.StaticText(DData,label='     Sequential Refinement Options'))
    925925            parmChoice = [' ','X','XU','U','F','FX','FXU','FU']
    926926            if generalData['Type'] == 'magnetic':
    … …  
    944944                if len(fixedVars):
    945945                    fixBox.Add(wx.StaticText(DData,label=' (currently {} fixed)'.format(len(fixedVars))),0,WACV)
    946             bottomSizer.Add(fixBox)
     946                bottomSizer.Add(fixBox)
    947947       
    948948        if not UseList[G2frame.hist]['LeBail'] or 'HKLF' in G2frame.hist[:4]:

  • trunk/GSASIIphsGUI.py

    r5042 r5043  
    29082908        G2frame.GPXtree.SetItemPyData(sub,newPhase)
    29092909        newPhase['Drawing'] = []
     2910        if 'RMC' in data: del newPhase['RMC']
    29102911        if ifConstr:
    29112912            G2cnstG.TransConstraints(G2frame,data,newPhase,Trans,Vvec,atCodes)     #data is old phase
    … …  
    47744775            return pairSizer
    47754776                   
     4777        def GetMetaSizer(metalist):
     4778            metaSizer = wx.FlexGridSizer(0,2,5,5)
     4779            for item in metalist:
     4780                metaSizer.Add(wx.StaticText(G2frame.FRMC,label=' Metadata item: '+item+' '),0,WACV)
     4781                metaSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict['metadata'],item),0,WACV)
     4782            return metaSizer
     4783           
     4784        def SetRestart(invalid,value,tc):
     4785            RMCPdict['ReStart'] = [True,True]
     4786               
     4787        def GetSuperSizer(Xmax):
     4788           superSizer = wx.BoxSizer(wx.HORIZONTAL)
     4789           axes = ['X','Y','Z']
     4790           for i,ax in enumerate(axes):
     4791               superSizer.Add(wx.StaticText(G2frame.FRMC,label=' %s-axis: '%ax),0,WACV)
     4792               superSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict['SuperCell'],
     4793                   i,xmin=1,xmax=Xmax,size=(50,25),OnLeave=SetRestart),0,WACV)
     4794           return superSizer
     4795                     
    47764796        def FileSizer(RMCdict,mainSizer):
    47774797           
    … …  
    47944814                    dlg.Destroy()
    47954815                    RMCPdict['ReStart'][0] = True
     4816                    if G2frame.RMCchoice == 'PDFfit':
     4817                        start = 0
     4818                        XY = np.empty((1,2))
     4819                        while XY.shape[0] == 1:
     4820                            try:
     4821                                XY = np.loadtxt(fName,skiprows=start)
     4822                            except ValueError:
     4823                                start += 1
     4824                        name = 'Ndata'
     4825                        if 'X' in fil:
     4826                            name = 'Xdata'
     4827                        RMCPdict[name]['Datarange'][0] = np.min(XY.T[0])
     4828                        RMCPdict[name]['Datarange'][1] = np.max(XY.T[0])
     4829                        RMCPdict[name]['Fitrange'][1] = np.max(XY.T[0])
    47964830                else:
    47974831                    dlg.Destroy()
    4798                     return
     4832                 
    47994833                wx.CallAfter(UpdateRMC)
    48004834       
    … …  
    48184852                if 'G(R)' in fileItem[2].upper():
    48194853                    Xlab = 'R'
    4820                 G2plt.PlotXY(G2frame,[XY.T,],labelX=Xlab,
     4854                G2plt.PlotXY(G2frame,[XY.T[:2],],labelX=Xlab,
    48214855                    labelY=fileItem[2],newPlot=True,Title=fileItem[0],
    48224856                    lines=True)
    … …  
    48304864                Obj = event.GetEventObject()
    48314865                fil = Indx[Obj.GetId()]
    4832                 RMCPdict['files'][fil][0] = 'Select file'
     4866                RMCPdict['files'][fil][0] = 'Select'
    48334867                RMCPdict['ReStart'][0] = True
    48344868                wx.CallAfter(UpdateRMC)
     4869               
     4870            def OnRef(event):
     4871                Obj = event.GetEventObject()
     4872                name,item = Indx[Obj.GetId()]
     4873                RMCPdict[name][item][1] = not RMCPdict[name][item][1]
    48354874                           
    48364875            Indx = {}
    48374876            mainSizer.Add(wx.StaticText(G2frame.FRMC,label='Select data for processing: '),0)
    48384877            if G2frame.RMCchoice == 'fullrmc':
    4839                 #Heads = ['Name','File','Weight','type','Plot','Delete']
    48404878                Heads = ['Name','File','type','Plot','Delete']
    48414879                fileSizer = wx.FlexGridSizer(5,5,5)
    … …  
    49154953                fileSizer.Add(wx.StaticText(G2frame.FRMC,label=head),0,WACV)
    49164954            for fil in RMCPdict['files']:
     4955                for head in Heads:
     4956                    fileSizer.Add(wx.StaticText(G2frame.FRMC,label=20*'-'),0,WACV)
    49174957                fileSizer.Add(wx.StaticText(G2frame.FRMC,label=fil),0,WACV)
    49184958                Rfile = RMCPdict['files'][fil][0]
    … …  
    49214961                Indx[filSel.GetId()] = fil
    49224962                fileSizer.Add(filSel,0,WACV)
     4963                nform = 3
     4964                Name = 'Ndata'
     4965                if 'Xray' in fil:
     4966                    nform = 1
     4967                    Name = 'Xdata'
    49234968                if Rfile and os.path.exists(Rfile): #incase .gpx file is moved away from G(R), F(Q), etc. files
    4924                     nform = 3
    4925                     if 'Xray' in fil: nform = 1
    49264969                    fileFormat = wx.ComboBox(G2frame.FRMC,choices=Formats[:nform],style=wx.CB_DROPDOWN|wx.TE_READONLY)
    49274970                    fileFormat.SetStringSelection(RMCPdict['files'][fil][3])
    … …  
    49444987                    fileSizer.Add((5,5),0)
    49454988                    fileSizer.Add((5,5),0)
     4989                if 'Select' not in Rfile and 'PDFfit' in G2frame.RMCchoice:
     4990                    fileSizer.Add(wx.StaticText(G2frame.FRMC,label=' Rrange (from/to)'),0,WACV)
     4991                    fileSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict[Name]['Fitrange'],0,xmin=RMCPdict[Name]['Datarange'][0],xmax=3.0),0,WACV)
     4992                    fileSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict[Name]['Fitrange'],1,xmin=10.0,xmax=RMCPdict[Name]['Datarange'][1]),0,WACV)
     4993                    fileSizer.Add(wx.StaticText(G2frame.FRMC,label=' Scale factor: '),0,WACV)
     4994                    fileSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict[Name]['dscale'],0,xmin=0.001,xmax=20.0),0,WACV)
     4995                    scaleref = wx.CheckBox(G2frame.FRMC,label='refine')
     4996                    scaleref.SetValue(RMCPdict[Name]['dscale'][1])
     4997                    Indx[scaleref.GetId()] = [Name,'dscale']
     4998                    scaleref.Bind(wx.EVT_CHECKBOX,OnRef)
     4999                    fileSizer.Add(scaleref,0,WACV)
     5000                    fileSizer.Add(wx.StaticText(G2frame.FRMC,label=' Qdamp '),0,WACV)
     5001                    fileSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict[Name]['qdamp'],0,xmin=0.001,xmax=1.0),0,WACV)
     5002                    qdampref = wx.CheckBox(G2frame.FRMC,label='refine')
     5003                    qdampref.SetValue(RMCPdict[Name]['qdamp'][1])
     5004                    Indx[qdampref.GetId()] = [Name,'qdamp']
     5005                    qdampref.Bind(wx.EVT_CHECKBOX,OnRef)
     5006                    fileSizer.Add(qdampref,0,WACV)
     5007                    fileSizer.Add(wx.StaticText(G2frame.FRMC,label=' Qbroad '),0,WACV)
     5008                    fileSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict[Name]['qbroad'],0,xmin=0.001,xmax=1.0),0,WACV)
     5009                    qbroadref = wx.CheckBox(G2frame.FRMC,label='refine')
     5010                    qbroadref.SetValue(RMCPdict[Name]['qbroad'][1])
     5011                    Indx[qbroadref.GetId()] = [Name,'qbroad']
     5012                    qbroadref.Bind(wx.EVT_CHECKBOX,OnRef)
     5013                    fileSizer.Add(qbroadref,0,WACV)
     5014                   
    49465015            mainSizer.Add(fileSizer,0)
    4947             fitscale = wx.CheckBox(G2frame.FRMC,label=' Fit scale factors?')
    4948             fitscale.SetValue(RMCPdict['FitScale'])
    4949             fitscale.Bind(wx.EVT_CHECKBOX,OnFitScale)
    4950             mainSizer.Add(fitscale,0)
     5016            if 'PDFfit' not in G2frame.RMCchoice:
     5017                fitscale = wx.CheckBox(G2frame.FRMC,label=' Fit scale factors?')
     5018                fitscale.SetValue(RMCPdict['FitScale'])
     5019                fitscale.Bind(wx.EVT_CHECKBOX,OnFitScale)
     5020                mainSizer.Add(fitscale,0)
     5021               
    49515022            return
    49525023       
    49535024        G2frame.GetStatusBar().SetStatusText('',1)
     5025        G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_ISODISTORT,True)
    49545026        if G2frame.RMCchoice == 'RMCProfile':
    49555027            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_SETUPRMC,True)
    … …  
    49575029            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_VIEWRMC,True)
    49585030            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_STOPRMC,False)
     5031            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_ISODISTORT,False)
    49595032        elif G2frame.RMCchoice == 'fullrmc':
    49605033            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_SETUPRMC,False)
    … …  
    49625035            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_VIEWRMC,False)
    49635036            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_STOPRMC,False)
     5037            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_ISODISTORT,False)
    49645038            #G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_STOPRMC,True)
    49655039        if G2frame.FRMC.GetSizer():
    … …  
    53705444                wx.CallAfter(UpdateRMC)
    53715445               
    5372             def GetMetaSizer():
    5373                 metalist = ['title','owner','material','phase','comment','source',]
    5374                 metaSizer = wx.FlexGridSizer(0,2,5,5)
    5375                 for item in metalist:
    5376                     metaSizer.Add(wx.StaticText(G2frame.FRMC,label=' Metadata item: '+item+' '),0,WACV)
    5377                     metaSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict['metadata'],item),0,WACV)
    5378                 return metaSizer
     5446            # def GetMetaSizer():
     5447            #     metalist = ['title','owner','material','phase','comment','source',]
     5448            #     metaSizer = wx.FlexGridSizer(0,2,5,5)
     5449            #     for item in metalist:
     5450            #         metaSizer.Add(wx.StaticText(G2frame.FRMC,label=' Metadata item: '+item+' '),0,WACV)
     5451            #         metaSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict['metadata'],item),0,WACV)
     5452            #     return metaSizer
    53795453           
    53805454            def GetTimeSizer():
    … …  
    53945468                return timeSizer
    53955469               
    5396             def GetSuperSizer():
    5397                 superSizer = wx.BoxSizer(wx.HORIZONTAL)
    5398                 axes = ['X','Y','Z']
    5399                 for i,ax in enumerate(axes):
    5400                     superSizer.Add(wx.StaticText(G2frame.FRMC,label=' %s-axis: '%ax),0,WACV)
    5401                     superSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict['SuperCell'],
    5402                         i,xmin=1,xmax=20,size=(50,25),OnLeave=SetRestart),0,WACV)
    5403                 return superSizer
     5470            # def GetSuperSizer(Xmax):
     5471            #     superSizer = wx.BoxSizer(wx.HORIZONTAL)
     5472            #     axes = ['X','Y','Z']
     5473            #     for i,ax in enumerate(axes):
     5474            #         superSizer.Add(wx.StaticText(G2frame.FRMC,label=' %s-axis: '%ax),0,WACV)
     5475            #         superSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict['SuperCell'],
     5476            #             i,xmin=1,xmax=xamx,size=(50,25),OnLeave=SetRestart),0,WACV)
     5477            #     return superSizer
    54045478                     
    54055479            def GetBvsSizer(pnl):
    … …  
    55855659                return bondSizer
    55865660
    5587            
    55885661            Indx = {}
    55895662
    55905663            mainSizer.Add(wx.StaticText(G2frame.FRMC,label=' Enter metadata items:'),0)
    5591             mainSizer.Add(GetMetaSizer(),0)
     5664            mainSizer.Add(GetMetaSizer(['title','owner','material','phase','comment','source',]),0)
    55925665           
    55935666            G2G.HorizontalLine(mainSizer,G2frame.FRMC)
    … …  
    55955668           
    55965669            mainSizer.Add(wx.StaticText(G2frame.FRMC,label=' Lattice multipliers; if changed will force reset of atom positions:'),0)
    5597             mainSizer.Add(GetSuperSizer(),0)
     5670            mainSizer.Add(GetSuperSizer(20),0)
    55985671           
    55995672            G2G.HorizontalLine(mainSizer,G2frame.FRMC)
    56005673           
    5601             # aPanel = wxscroll.ScrolledPanel(G2frame.FRMC, wx.ID_ANY,
    5602             #     style=wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
    5603             # mSizer = wx.BoxSizer(wx.VERTICAL)
    5604             # mSizer.Add(wx.StaticText(aPanel,label='Enter atom settings'),0)
    5605             # mSizer.Add(GetAtmChoice(aPanel,RMCPdict),0)
    5606             # mSizer.Add(wx.StaticText(aPanel,label=' N.B.: be sure to set cations first && anions last in atom ordering'))
    5607             # mSizer.Layout()
    5608             # aPanel.SetSizer(mSizer)
    5609             # aPanel.SetMinSize((300,mSizer.GetMinSize()[1]))
    5610             # aPanel.SetAutoLayout(1)
    5611             # aPanel.SetupScrolling()
    5612             # mainSizer.Add(aPanel,1,wx.EXPAND)
    56135674            mSizer = wx.BoxSizer(wx.VERTICAL)
    56145675            mSizer.Add(wx.StaticText(G2frame.FRMC,label='Enter atom settings'),0)
    … …  
    56285689           
    56295690            G2G.HorizontalLine(mainSizer,G2frame.FRMC)
    5630 
    5631             # sPanel = wxscroll.ScrolledPanel(G2frame.FRMC, wx.ID_ANY,
    5632             #     style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
    5633             # mSizer = wx.BoxSizer(wx.VERTICAL)
    5634             # mSizer.Add(wx.StaticText(sPanel,label='Enter constraints && restraints via minimum && maximum distances for atom pairs:'),0)
    5635             # mSizer.Add(GetPairSizer(sPanel,RMCPdict),0)
    5636             # sPanel.SetSizer(mSizer)
    5637             # mSizer.Layout()
    5638             # sPanel.SetMinSize((300,25+mSizer.GetMinSize()[1]))
    5639             # sPanel.SetAutoLayout(1)
    5640             # sPanel.SetupScrolling()
    5641             # mainSizer.Add(sPanel,1,wx.EXPAND)
    56425691           
    56435692            mSizer = wx.BoxSizer(wx.VERTICAL)
    … …  
    56525701            mainSizer.Add(useBVS,0)
    56535702            if RMCPdict.get('useBVS',False):
    5654                 # sPanel = wxscroll.ScrolledPanel(G2frame.FRMC, wx.ID_ANY,
    5655                 #     style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER)
    5656                 # mSizer = wx.BoxSizer(wx.VERTICAL)
    5657                 # mSizer.Add(GetBvsSizer(sPanel),0)
    5658                 # sPanel.SetSizer(mSizer)
    5659                 # mSizer.Layout()
    5660                 # sPanel.SetMinSize((300,25+mSizer.GetMinSize()[1]))
    5661                 # sPanel.SetAutoLayout(1)
    5662                 # sPanel.SetupScrolling()
    5663                 # mainSizer.Add(sPanel,1,wx.EXPAND)
    56645703                mSizer = wx.BoxSizer(wx.VERTICAL)
    56655704                mSizer.Add(GetBvsSizer(G2frame.FRMC),0)
    … …  
    57385777            FileSizer(RMCPdict,mainSizer)
    57395778        else:
     5779            Indx = {}
     5780            def PDFParmSizer():
     5781               
     5782                parmSizer = wx.FlexGridSizer(3,6,5,5)
     5783                Names = ['delta1','delta2','spdiameter','sratio']
     5784                Names2 = ['rcut','stepcut']
     5785                for name in Names:
     5786                   
     5787                    def OnRefine(event):
     5788                        Obj = event.GetEventObject()
     5789                        name = Indx[Obj.GetId()]
     5790                        RMCPdict[name][1] = not RMCPdict[name][1]
     5791                       
     5792                    parmSizer.Add(wx.StaticText(G2frame.FRMC,label=name),0,WACV)
     5793                    parmSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict[name],0,xmin=0.,size=(70,25)),0,WACV)
     5794                    refine = wx.CheckBox(G2frame.FRMC,label='Refine')
     5795                    refine.SetValue(RMCPdict[name][1])
     5796                    refine.Bind(wx.EVT_CHECKBOX,OnRefine)
     5797                    Indx[refine.GetId()] = name
     5798                    parmSizer.Add(refine,0,WACV)
     5799                   
     5800                for name in Names2:
     5801                    parmSizer.Add(wx.StaticText(G2frame.FRMC,label=name),0,WACV)
     5802                    parmSizer.Add(G2G.ValidatedTxtCtrl(G2frame.FRMC,RMCPdict,name,xmin=0.,size=(70,25)),0,WACV)                   
     5803                   
     5804                return parmSizer
     5805           
    57405806            subSizer = wx.BoxSizer(wx.HORIZONTAL)
    57415807            subSizer.Add((-1,-1),1,wx.EXPAND)
    … …  
    57535819                Atypes = [atype.split('+')[0].split('-')[0] for atype in data['General']['AtomTypes']]
    57545820                aTypes = dict(zip(Atypes,len(Atypes)*[0.10,]))
     5821                metadata = {'title':'none','date':str(time.ctime()),'temperature':'300K',
     5822                    'doping':0}
    57555823                files = {'Neutron real space data; G(r): ':['Select',0.05,'G(r)','RMC',],
    57565824                          'Xray real space data; G(r): ':['Select',0.01,'G(r)','RMC',],}
    5757                 data['RMC']['PDFfit'] = {'files':files}
     5825                data['RMC']['PDFfit'] = {'files':files,'ReStart':[False,False],'metadata':metadata,
     5826                'delta1':[0.,False],'delta2':[0.,False],'spdiameter':[0.,False],
     5827                'sratio':[1.,False],'rcut':0.0,'stepcut':0.0,         
     5828                'Xdata':{'dscale':[1.0,False],'Datarange':[0.,30.],'Fitrange':[0.,30.],'qdamp':[0.03,False],'qbroad':[0,False]},
     5829                'Ndata':{'dscale':[1.0,False],'Datarange':[0.,30.],'Fitrange':[0.,30.],'qdamp':[0.03,False],'qbroad':[0,False]},}
    57585830               
    57595831            RMCPdict = data['RMC']['PDFfit']
     5832            mainSizer.Add(wx.StaticText(G2frame.FRMC,label=' Enter metadata items:'),0)
     5833            mainSizer.Add(GetMetaSizer(['title','date','temperature','doping']),0)
     5834           
     5835            G2G.HorizontalLine(mainSizer,G2frame.FRMC)
     5836            mainSizer.Add(wx.StaticText(G2frame.FRMC,label=' PDF profile coefficients:'),0,WACV)
     5837            mainSizer.Add(PDFParmSizer(),0)
     5838           
     5839            G2G.HorizontalLine(mainSizer,G2frame.FRMC)
     5840            FileSizer(RMCPdict,mainSizer)
     5841
    57605842        bigSizer.Add(mainSizer,1,wx.EXPAND)
    57615843        # add help button to bring up help web page - at right side of window
    … …  
    58295911                G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_RUNRMC,False)
    58305912        elif G2frame.RMCchoice == 'PDFfit':
     5913            pName = generalData['Name'].replace(' ','_')
     5914            G2frame.dataWindow.FRMCDataEdit.Enable(G2G.wxID_RUNRMC,True)
     5915            RMCPdict = data['RMC']['PDFfit']
     5916            title = RMCPdict['metadata']['title']
     5917            print(RMCPdict)
     5918           
    58315919            print('PDFfit2 prep under construction')
    58325920           
    … …  
    59756063                return
    59766064            pName = generalData['Name'].replace(' ','_')
    5977             rname = pName+'_PDFfit.py'
     6065            rname = pName+'-PDFfit.py'
    59786066            if not os.path.exists(rname):
    59796067                G2G.G2MessageBox(G2frame,
    … …  
    63846472            RMCPdict = data['RMC']['PDFfit']
    63856473            pName = generalData['Name'].replace(' ','_')
     6474            print(data['RMC']['PDFfit'])
    63866475            print('PDFfit plots under construction')
    6387        
    6388            
    6389 ### Layer Data page ################################################################################
     6476           
     6477    def OnRunISODISTORT(event):
     6478        import ISODISTORT as ISO
     6479        ISO.GetISODISTORT(data)
     6480        print('run ISODISTORT under construction')
     6481       
     6482       
     6483           
     6484#### DIFFax Layer Data page ################################################################################
    63906485    def UpdateLayerData(Scroll=0):
    63916486        '''Present the contents of the Phase/Layers tab for stacking fault simulation
    … …  
    1311113206        G2frame.Bind(wx.EVT_MENU, OnViewRMC, id=G2G.wxID_VIEWRMC)
    1311213207        G2frame.Bind(wx.EVT_MENU, OnStopRMC, id=G2G.wxID_STOPRMC)
     13208        G2frame.Bind(wx.EVT_MENU, OnRunISODISTORT, id=G2G.wxID_ISODISTORT)
    1311313209        # MC/SA
    1311413210        FillSelectPageMenu(TabSelectionIdDict, G2frame.dataWindow.MCSAMenu)
    … …  
    1319913295        data['General']['Type'] = 'nuclear'
    1320013296    if 'RMC' not in data:
    13201         data['RMC'] = {'RMCProfile':{},'fullrmc':{}}
     13297        data['RMC'] = {'RMCProfile':{},'fullrmc':{},'PDFfit':{}}
    1320213298#end patch   
    1320313299

  • trunk/GSASIIpwd.py

    r5041 r5043  
    29372937    except:
    29382938        return None
     2939   
     2940def MakePDFfitAtomsFile(Phase,RMCPdict):
     2941    '''Make the PDFfit atoms file
     2942    '''
     2943    General = Phase['General']
     2944    print(RMCPdict)
     2945    fName = Phase['Name']+'.stru'
     2946    fatm = open(fName.replace(' ','_'),'w')
     2947    a,b,c,alp,bet,gam = General['Cell'][1:7]
     2948    fatm.write('\n')
     2949   
    29392950       
    29402951def MakefullrmcRun(pName,Phase,RMCPdict):

  • trunk/GSASIIstrMain.py

    r5038 r5043  
    719719                if parm in parmDict:
    720720                    parmDict[parm] = NewparmDict[parm]
     721####TBD: if LeBail copy reflections here?
    721722        elif histogram in SeqResult:  # update phase from last seq ref
    722723            NewparmDict = SeqResult[histogram].get('parmDict',{})

  • trunk/imports/G2phase_CIF.py

    r5038 r5043  
    10321032                l = ''
    10331033                s = 0.0
    1034                 at,d = lbl.split('_')
     1034                at,d = lbl.rsplit('_',1)
    10351035                if at not in DeltaCoords:
    10361036                    DeltaCoords[at] = [0,0,0]
Note: See TracChangeset for help on using the changeset viewer.