Changeset 687


Ignore:
Timestamp:
Jul 12, 2012 3:10:16 PM (9 years ago)
Author:
vondreele
Message:

histogram wtFactors for PWDR & HKLF (latter not implemented yet)
means that data[0] is now {'wtFactor':1.0} instead of a mostly unused file name
also put in atomIndx for doing restraint calcs.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASII.py

    r686 r687  
    499499            Id = self.PatternTree.AppendItem(parent=self.root,
    500500                                             text='HKLF '+HistName)
    501             self.PatternTree.SetItemPyData(Id,['HKLF '+HistName,rd.RefList])
     501            self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0},rd.RefList])
    502502            Sub = self.PatternTree.AppendItem(Id,text='Instrument Parameters')
    503503            self.PatternTree.SetItemPyData(Sub,rd.Parameters)
     
    618618                return Iparm
    619619            else:
    620                 print 'debug: open/read failed',instfile
     620#                print 'debug: open/read failed',instfile
    621621                pass # fail silently
    622622
     
    754754                parent=self.root,
    755755                text='PWDR '+rd.idstring)
    756             self.PatternTree.SetItemPyData(Id,[rd.powderentry,rd.powderdata])
     756#            self.PatternTree.SetItemPyData(Id,[rd.powderentry,rd.powderdata])
     757            self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0},rd.powderdata])
    757758            self.PatternTree.SetItemPyData(
    758759                self.PatternTree.AppendItem(Id,text='Comments'),
     
    14261427                    if Id:
    14271428                        Sample = G2pdG.SetDefaultSample()
    1428                         self.PatternTree.SetItemPyData(Id,[[''],[np.array(Xsum),np.array(Ysum),np.array(Wsum),
     1429                        self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0},[np.array(Xsum),np.array(Ysum),np.array(Wsum),
    14291430                            np.array(YCsum),np.array(YBsum),np.array(YDsum)]])
    14301431                        self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),Comments)                   
     
    17331734                dlg.Destroy()
    17341735
    1735 
    17361736    def OnFileClose(self, event):
    17371737        if self.dataFrame:
     
    17851785            self.dataFrame.Destroy()
    17861786        self.Close()
    1787        
    1788     def OnImportPattern(self,event):
    1789         dlg = wx.FileDialog(self, 'Choose nonGSAS powder file', '.', '',
    1790             '(*.*)|*.*',wx.OPEN|wx.CHANGE_DIR)
    1791         try:
    1792             if dlg.ShowModal() == wx.ID_OK:
    1793                 self.powderfile = dlg.GetPath()
    1794         finally:
    1795             dlg.Destroy()
    1796            
    1797     def OnImportHKL(self,event):
    1798         dlg = wx.FileDialog(self, 'Choose structure factor file', '.', '',
    1799             '(*.*)|*.*',wx.OPEN|wx.CHANGE_DIR)
    1800         try:
    1801             if dlg.ShowModal() == wx.ID_OK:
    1802                 self.HKLfile = dlg.GetPath()
    1803         finally:
    1804             dlg.Destroy()
    18051787       
    18061788    def OnExportPatterns(self,event):
     
    20392021        Histograms,Phases = self.GetUsedHistogramsAndPhasesfromTree()
    20402022        print Histograms.keys()
    2041         Natoms,phaseVary,phaseDict,pawleyLookup,FFtable,BLtable = G2str.GetPhaseData(Phases,RestDict=None,Print=False)       
     2023        Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtable,BLtable = G2str.GetPhaseData(Phases,RestDict=None,Print=False)       
    20422024        hapVary,hapDict,controlDict = G2str.GetHistogramPhaseData(Phases,Histograms,Print=False)
    20432025        histVary,histDict,controlDict = G2str.GetHistogramData(Histograms,Print=False)
  • trunk/GSASIIgrid.py

    r685 r687  
    11091109    Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
    11101110    AtomDict = dict([Phases[phase]['pId'],Phases[phase]['Atoms']] for phase in Phases)
    1111     Natoms,phaseVary,phaseDict,pawleyLookup,FFtable,BLtable = G2str.GetPhaseData(Phases,Print=False)
     1111    Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtable,BLtable = G2str.GetPhaseData(Phases,Print=False)
    11121112    phaseList = []
    11131113    for item in phaseDict:
     
    19081908    G2frame.dataDisplay.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, OnPageChanged)
    19091909   
    1910 def UpdatePWDPlot(G2frame,item):
     1910def UpdatePWHKPlot(G2frame,kind,item):
    19111911
    19121912    def OnErrorAnalysis(event):
    1913         G2plt.PlotDeltSig(G2frame)
    1914    
    1915     defWid = [250,150]
     1913        G2plt.PlotDeltSig(G2frame,kind)
     1914       
     1915    def OnWtFactor(event):
     1916        try:
     1917            val = float(wtval.GetValue())
     1918        except ValueError:
     1919            val = data[0]['wtFactor']
     1920        data[0]['wtFactor'] = val
     1921        wtval.SetValue('%.3f'%(val))
     1922           
     1923    data = G2frame.PatternTree.GetItemPyData(item)
     1924    if 'wtFactor' not in data[0]:
     1925        data[0] = {'wtFactor':1.0}
    19161926    if G2frame.dataDisplay:
    19171927        G2frame.dataDisplay.Destroy()
    19181928    G2frame.dataFrame.SetMenuBar(G2frame.dataFrame.ErrorMenu)
    19191929    G2frame.dataFrame.Bind(wx.EVT_MENU,OnErrorAnalysis, id=wxID_PWDANALYSIS)
    1920     G2frame.dataFrame.setSizePosLeft(defWid)
    1921     wx.TextCtrl(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize(),
    1922         style=wx.TE_MULTILINE,
    1923         value='See plot window for powder data display\nor select a data item in histogram')
    1924     G2plt.PlotPatterns(G2frame,newPlot=True)
    1925            
    1926              
     1930    G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
     1931   
     1932    mainSizer = wx.BoxSizer(wx.VERTICAL)
     1933    mainSizer.Add((5,5),)
     1934    wtSizer = wx.BoxSizer(wx.HORIZONTAL)
     1935    wtSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Weight factor: '),0,wx.ALIGN_CENTER_VERTICAL)
     1936    wtval = wx.TextCtrl(G2frame.dataDisplay,-1,'%.3f'%(data[0]['wtFactor']),style=wx.TE_PROCESS_ENTER)
     1937    wtval.Bind(wx.EVT_TEXT_ENTER,OnWtFactor)
     1938    wtval.Bind(wx.EVT_KILL_FOCUS,OnWtFactor)
     1939    wtSizer.Add(wtval,0,wx.ALIGN_CENTER_VERTICAL)
     1940    mainSizer.Add(wtSizer)
     1941    mainSizer.Layout()   
     1942    G2frame.dataDisplay.SetSizer(mainSizer)
     1943    G2frame.dataFrame.setSizePosLeft(mainSizer.Fit(G2frame.dataFrame))
     1944    G2frame.PatternTree.SetItemPyData(item,data)
     1945    if kind == 'PWDR':
     1946        G2plt.PlotPatterns(G2frame,newPlot=True)
     1947    elif kind == 'HKLF':
     1948        G2plt.PlotSngl(G2frame,newPlot=True)
     1949                 
    19271950def UpdateHKLControls(G2frame,data):
    19281951   
     
    21232146        elif 'PWDR' in G2frame.PatternTree.GetItemText(item):
    21242147            G2frame.ExportPattern.Enable(True)
    2125             UpdatePWDPlot(G2frame,item)
     2148            UpdatePWHKPlot(G2frame,'PWDR',item)
    21262149        elif 'HKLF' in G2frame.PatternTree.GetItemText(item):
    21272150            G2frame.Sngl = item
    2128             G2plt.PlotSngl(G2frame,newPlot=True)
     2151            UpdatePWHKPlot(G2frame,'HKLF',item)
    21292152        elif 'PDF' in G2frame.PatternTree.GetItemText(item):
    21302153            G2frame.PatternId = item
     
    22672290    elif G2frame.PatternTree.GetItemText(item) == 'Reflection List':    #HKLF reflections
    22682291        G2frame.PatternId = G2frame.PatternTree.GetItemParent(item)
     2292        name = G2frame.PatternTree.GetItemText(G2frame.PatternId)
    22692293        data = G2frame.PatternTree.GetItemPyData(G2frame.PatternId)
    2270         G2pdG.UpdateReflectionGrid(G2frame,data,HKLF=True)
     2294        G2pdG.UpdateReflectionGrid(G2frame,data,HKLF=True,Name=name)
  • trunk/GSASIIplot.py

    r683 r687  
    791791################################################################################
    792792           
    793 def PlotDeltSig(G2frame):
     793def PlotDeltSig(G2frame,kind):
    794794    try:
    795795        plotNum = G2frame.G2plotNB.plotList.index('Error analysis')
     
    806806    Pattern = G2frame.PatternTree.GetItemPyData(PatternId)
    807807    Pattern.append(G2frame.PatternTree.GetItemText(PatternId))
    808     limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
    809     xye = np.array(Pattern[1])
    810     xmin = np.searchsorted(xye[0],limits[0])
    811     xmax = np.searchsorted(xye[0],limits[1])
    812     X = xye[0][xmin:xmax]
    813     DS = xye[5][xmin:xmax]*np.sqrt(xye[2][xmin:xmax])
     808    wtFactor = Pattern[0]['wtFactor']
     809    if kind == 'PWDR':
     810        limits = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,PatternId, 'Limits'))[1]
     811        xye = np.array(Pattern[1])
     812        xmin = np.searchsorted(xye[0],limits[0])
     813        xmax = np.searchsorted(xye[0],limits[1])
     814        DS = xye[5][xmin:xmax]*np.sqrt(wtFactor*xye[2][xmin:xmax])
     815    elif kind == 'HKLF':
     816        refl = Pattern[1]
     817        DS = []
     818        for ref in refl:
     819            if ref[6] > 0.:
     820                DS.append((ref[5]-ref[7])/ref[6])
    814821    Page.SetFocus()
    815822    G2frame.G2plotNB.status.DestroyChildren()
  • trunk/GSASIIpwdGUI.py

    r685 r687  
    17561756################################################################################           
    17571757       
    1758 def UpdateReflectionGrid(G2frame,data,HKLF=False):
     1758def UpdateReflectionGrid(G2frame,data,HKLF=False,Name=''):
    17591759    if not data:
    17601760        print 'No phases, no reflections'
     
    17621762    if HKLF:
    17631763        G2frame.RefList = 1
    1764         phaseName = data[0]
     1764        phaseName = Name
    17651765    else:
    17661766        phaseName = G2frame.RefList
  • trunk/GSASIIstruct.py

    r686 r687  
    128128    if not Histograms:
    129129        return 'Error: no diffraction data',''
    130     Natoms,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables = GetPhaseData(Phases,RestDict=None,Print=False)
     130    Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables = GetPhaseData(Phases,RestraintDict=None,Print=False)
    131131    hapVary,hapDict,controlDict = GetHistogramPhaseData(Phases,Histograms,Print=False)
    132132    histVary,histDict,controlDict = GetHistogramData(Histograms,Print=False)
     
    146146        datum = data[0]
    147147        if datum[0] == 'Restraints':
    148             restDict = datum[1]
     148            restraintDict = datum[1]
    149149    fl.close()
    150     return restDict
     150    return restraintDict
    151151   
    152152def GetPhaseNames(GPXfile):
     
    215215            if 'PWDR' in hist[:4]:
    216216                PWDRdata = {}
     217                try:
     218                    PWDRdata.update(datum[1][0])        #weight factor
     219                except ValueError:
     220                    PWDRdata['wtFactor'] = 1.0          #patch
    217221                PWDRdata['Data'] = datum[1][1]          #powder data arrays
    218222                PWDRdata[data[2][0]] = data[2][1]       #Limits
     
    228232            elif 'HKLF' in hist[:4]:
    229233                HKLFdata = {}
     234                try:
     235                    HKLFdata.update(datum[1][0])        #weight factor
     236                except ValueError:
     237                    HKLFdata['wtFactor'] = 1.0          #patch
    230238                HKLFdata['Data'] = datum[1][1]
    231239                HKLFdata[data[1][0]] = data[1][1]       #Instrument parameters
     
    402410    print 'GPX file save successful'
    403411                       
    404 def GetPWDRdata(GPXfile,PWDRname):
    405     ''' Returns powder data from GSASII gpx file
    406     input:
    407         GPXfile = .gpx full file name
    408         PWDRname = powder histogram name as obtained from GetHistogramNames
    409     return:
    410         PWDRdata = powder data dictionary with:
    411             Data - powder data arrays, Limits, Instrument Parameters, Sample Parameters
    412        
    413     '''
    414     fl = open(GPXfile,'rb')
    415     PWDRdata = {}
    416     while True:
    417         try:
    418             data = cPickle.load(fl)
    419         except EOFError:
    420             break
    421         datum = data[0]
    422         if datum[0] == PWDRname:
    423             PWDRdata['Data'] = datum[1][1]          #powder data arrays
    424             PWDRdata[data[2][0]] = data[2][1]       #Limits
    425             PWDRdata[data[3][0]] = data[3][1]       #Background
    426             PWDRdata[data[4][0]] = data[4][1]       #Instrument parameters
    427             PWDRdata[data[5][0]] = data[5][1]       #Sample parameters
    428             try:
    429                 PWDRdata[data[9][0]] = data[9][1]       #Reflection lists might be missing
    430             except IndexError:
    431                 PWDRdata['Reflection Lists'] = {}
    432     fl.close()
    433     return PWDRdata
    434    
    435 def GetHKLFdata(GPXfile,HKLFname):
    436     ''' Returns single crystal data from GSASII gpx file
    437     input:
    438         GPXfile = .gpx full file name
    439         HKLFname = single crystal histogram name as obtained from GetHistogramNames
    440     return:
    441         HKLFdata = single crystal data list of reflections: for each reflection:
    442             HKLF = [np.array([h,k,l]),FoSq,sigFoSq,FcSq,Fcp,Fcpp,phase]
    443             need this [h,k,l,mul,d,pos,0.0,0.0,0.0,0.0,0.0,Uniq,phi,0.0,{}]
    444     '''
    445     fl = open(GPXfile,'rb')
    446     HKLFdata = {}
    447     while True:
    448         try:
    449             data = cPickle.load(fl)
    450         except EOFError:
    451             break
    452         datum = data[0]
    453         if datum[0] == HKLFname:
    454             HKLFdata['Data'] = datum[1:][0]       
    455             HKLFdata['Reflection Lists'] = None
    456     fl.close()
    457     return HKLFdata
    458    
    459412def ShowBanner():
    460413    print 80*'*'
     
    575528################################################################################       
    576529                   
    577 def GetPhaseData(PhaseData,RestDict=None,Print=True):
     530def GetPhaseData(PhaseData,RestraintDict=None,Print=True):
    578531           
    579532    def PrintFFtable(FFtable):
     
    679632    shModels = ['cylindrical','none','shear - 2/m','rolling - mmm']
    680633    SamSym = dict(zip(shModels,['0','-1','2/m','mmm']))
     634    atomIndx = {}
    681635    for name in PhaseData:
    682636        General = PhaseData[name]['General']
     
    704658                Natoms[pfx] = len(Atoms)
    705659                for i,at in enumerate(Atoms):
     660                    atomIndx[at[-1]] = [pfx,i]      #lookup table for restraints
    706661                    phaseDict.update({pfx+'Atype:'+str(i):at[1],pfx+'Afrac:'+str(i):at[6],pfx+'Amul:'+str(i):at[8],
    707662                        pfx+'Ax:'+str(i):at[3],pfx+'Ay:'+str(i):at[4],pfx+'Az:'+str(i):at[5],
     
    747702#            elif General['Type'] == 'magnetic':
    748703#            elif General['Type'] == 'macromolecular':
    749 
    750704            textureData = General['SH Texture']
    751705            if textureData['Order']:
     
    773727                    '%.3f'%(cell[6]),' volume =','%.3f'%(cell[7]),' Refine?',cell[0]
    774728                PrintTexture(textureData)
    775                 if name in RestDict:
    776                     PrintRestraints(RestDict[name])
     729                if name in RestraintDict:
     730                    PrintRestraints(RestraintDict[name])
    777731                   
    778732        elif PawleyRef:
     
    786740            phaseVary += pawleyVary
    787741               
    788     return Natoms,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables
     742    return Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables
    789743   
    790744def cellFill(pfx,SGData,parmDict,sigDict):
     
    15031457                print ' Final refinement RF, RF^2 = %.2f%%, %.2f%% on %d reflections'   \
    15041458                    %(Histogram[pfx+'Rf'],Histogram[pfx+'Rf^2'],Histogram[pfx+'Nref'])
     1459                print ' HKLF histogram weight factor = ','%.3f'%(Histogram['wtFactor'])
    15051460                ScalExtSig = {}
    15061461                for item in ['Scale','Ep','Eg','Es']:
     
    16871642            hId = Histogram['hId']
    16881643            pfx = ':'+str(hId)+':'
     1644            controlDict[pfx+'wtFactor'] =Histogram['wtFactor']
    16891645            controlDict[pfx+'Limits'] = Histogram['Limits'][1]
    16901646           
     
    17101666            histDict.update(sampDict)
    17111667            histVary += sampVary
     1668           
    17121669   
    17131670            if Print:
     
    17261683            hId = Histogram['hId']
    17271684            pfx = ':'+str(hId)+':'
     1685            controlDict[pfx+'wtFactor'] =Histogram['wtFactor']
    17281686            Inst = Histogram['Instrument Parameters']
    17291687            controlDict[pfx+'histType'] = Inst[1][0]
     
    19081866            print 135*'-'
    19091867            print ' Final refinement wR = %.2f%% on %d observations in this histogram'%(Histogram['wR'],Histogram['Nobs'])
     1868            print ' PWDR histogram weight factor = '+'%.3f'%(Histogram['wtFactor'])
    19101869            if Print:
    19111870                print ' Instrument type: ',Sample['Type']
     
    29492908    parmdict.update(zip(varylist,values))
    29502909    G2mv.Dict2Map(parmdict,varylist)
    2951     Histograms,Phases,restDict = HistoPhases
     2910    Histograms,Phases,restraintDict = HistoPhases
    29522911    nvar = len(varylist)
    29532912    dMdv = np.empty(0)
     
    29592918            hId = Histogram['hId']
    29602919            hfx = ':%d:'%(hId)
     2920            wtFactor = calcControls[hfx+'wtFactor']
    29612921            Limits = calcControls[hfx+'Limits']
    29622922            x,y,w,yc,yb,yd = Histogram['Data']
     2923            W = wtFactor*w
    29632924            xB = np.searchsorted(x,Limits[0])
    29642925            xF = np.searchsorted(x,Limits[1])
    2965             dMdvh = np.sqrt(w[xB:xF])*getPowderProfileDerv(parmdict,x[xB:xF],
     2926            dMdvh = np.sqrt(W[xB:xF])*getPowderProfileDerv(parmdict,x[xB:xF],
    29662927                varylist,Histogram,Phases,calcControls,pawleyLookup)
    29672928        elif 'HKLF' in histogram[:4]:
     
    29722933            hId = Histogram['hId']
    29732934            hfx = ':%d:'%(hId)
     2935            wtFactor = calcControls[hfx+'wtFactor']
    29742936            pfx = '%d::'%(Phase['pId'])
    29752937            phfx = '%d:%d:'%(Phase['pId'],hId)
     
    30142976    parmdict.update(zip(varylist,values))
    30152977    G2mv.Dict2Map(parmdict,varylist)
    3016     Histograms,Phases,restDict = HistoPhases
     2978    Histograms,Phases,restraintDict = HistoPhases
    30172979    nvar = len(varylist)
    30182980    Hess = np.empty(0)
     
    30242986            hId = Histogram['hId']
    30252987            hfx = ':%d:'%(hId)
     2988            wtFactor = calcControls[hfx+'wtFactor']
    30262989            Limits = calcControls[hfx+'Limits']
    30272990            x,y,w,yc,yb,yd = Histogram['Data']
     2991            W = wtFactor*w
    30282992            dy = y-yc
    30292993            xB = np.searchsorted(x,Limits[0])
    30302994            xF = np.searchsorted(x,Limits[1])
    3031             dMdvh = np.sqrt(w[xB:xF])*getPowderProfileDerv(parmdict,x[xB:xF],
     2995            dMdvh = np.sqrt(W[xB:xF])*getPowderProfileDerv(parmdict,x[xB:xF],
    30322996                varylist,Histogram,Phases,calcControls,pawleyLookup)
    30332997            if dlg:
    30342998                dlg.Update(Histogram['wR'],newmsg='Hessian for histogram %d Rw=%8.3f%s'%(hId,Histogram['wR'],'%'))[0]
    30352999            if len(Hess):
    3036                 Vec += np.sum(dMdvh*np.sqrt(w[xB:xF])*dy[xB:xF],axis=1)
     3000                Vec += np.sum(dMdvh*np.sqrt(W[xB:xF])*dy[xB:xF],axis=1)
    30373001                Hess += np.inner(dMdvh,dMdvh)
    30383002            else:
    3039                 Vec = np.sum(dMdvh*np.sqrt(w[xB:xF])*dy[xB:xF],axis=1)
     3003                Vec = np.sum(dMdvh*np.sqrt(W[xB:xF])*dy[xB:xF],axis=1)
    30403004                Hess = np.inner(dMdvh,dMdvh)
    30413005        elif 'HKLF' in histogram[:4]:
     
    30463010            hId = Histogram['hId']
    30473011            hfx = ':%d:'%(hId)
     3012            wtFactor = calcControls[hfx+'wtFactor']
    30483013            pfx = '%d::'%(Phase['pId'])
    30493014            phfx = '%d:%d:'%(Phase['pId'],hId)
     
    31003065    Values2Dict(parmdict, varylist, values)
    31013066    G2mv.Dict2Map(parmdict,varylist)
    3102     Histograms,Phases,restDict = HistoPhases
     3067    Histograms,Phases,restraintDict = HistoPhases
    31033068    M = np.empty(0)
    31043069    SumwYo = 0
     
    31113076            hId = Histogram['hId']
    31123077            hfx = ':%d:'%(hId)
     3078            wtFactor = calcControls[hfx+'wtFactor']
    31133079            Limits = calcControls[hfx+'Limits']
    31143080            x,y,w,yc,yb,yd = Histogram['Data']
     3081            W = wtFactor*w
    31153082            yc *= 0.0                           #zero full calcd profiles
    31163083            yb *= 0.0
     
    31203087            Histogram['Nobs'] = xF-xB
    31213088            Nobs += Histogram['Nobs']
    3122             Histogram['sumwYo'] = np.sum(w[xB:xF]*y[xB:xF]**2)
     3089            Histogram['sumwYo'] = np.sum(W[xB:xF]*y[xB:xF]**2)
    31233090            SumwYo += Histogram['sumwYo']
    31243091            yc[xB:xF],yb[xB:xF] = getPowderProfile(parmdict,x[xB:xF],
     
    31263093            yc[xB:xF] += yb[xB:xF]
    31273094            yd[xB:xF] = y[xB:xF]-yc[xB:xF]
    3128             Histogram['sumwYd'] = np.sum(np.sqrt(w[xB:xF])*(yd[xB:xF]))
    3129             wdy = -np.sqrt(w[xB:xF])*(yd[xB:xF])
     3095            Histogram['sumwYd'] = np.sum(np.sqrt(W[xB:xF])*(yd[xB:xF]))
     3096            wdy = -np.sqrt(W[xB:xF])*(yd[xB:xF])
    31303097            Histogram['wR'] = min(100.,np.sqrt(np.sum(wdy**2)/Histogram['sumwYo'])*100.)
    31313098            if dlg:
     
    31393106            hId = Histogram['hId']
    31403107            hfx = ':%d:'%(hId)
     3108            wtFactor = calcControls[hfx+'wtFactor']
    31413109            pfx = '%d::'%(Phase['pId'])
    31423110            phfx = '%d:%d:'%(Phase['pId'],hId)
     
    32183186    calcControls.update(Controls)           
    32193187    constrDict,fixedList = GetConstraints(GPXfile)
    3220     restDict = GetRestraints(GPXfile)
     3188    restraintDict = GetRestraints(GPXfile)
    32213189    Histograms,Phases = GetUsedHistogramsAndPhases(GPXfile)
    32223190    if not Phases:
     
    32283196        print ' *** Refine aborted ***'
    32293197        raise Exception       
    3230     Natoms,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables = GetPhaseData(Phases,restDict)
     3198    Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables = GetPhaseData(Phases,restraintDict)
     3199    calcControls['atomIndx'] = atomIndx
    32313200    calcControls['Natoms'] = Natoms
    32323201    calcControls['FFtables'] = FFtables
     
    32723241            result = so.leastsq(errRefine,values,Dfun=dervRefine,full_output=True,
    32733242                ftol=Ftol,col_deriv=True,factor=Factor,
    3274                 args=([Histograms,Phases,restDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
     3243                args=([Histograms,Phases,restraintDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
    32753244            ncyc = int(result[2]['nfev']/2)
    32763245        elif 'Hessian' in Controls['deriv type']:
    32773246            result = G2mth.HessianLSQ(errRefine,values,Hess=HessRefine,ftol=Ftol,maxcyc=maxCyc,
    3278                 args=([Histograms,Phases,restDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
     3247                args=([Histograms,Phases,restraintDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
    32793248            ncyc = result[2]['num cyc']+1
    32803249            Rvals['lamMax'] = result[2]['lamMax']
    32813250        else:           #'numeric'
    32823251            result = so.leastsq(errRefine,values,full_output=True,ftol=Ftol,epsfcn=1.e-8,factor=Factor,
    3283                 args=([Histograms,Phases,restDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
     3252                args=([Histograms,Phases,restraintDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
    32843253            ncyc = int(result[2]['nfev']/len(varyList))
    32853254#        table = dict(zip(varyList,zip(values,result[0],(result[0]-values))))
     
    33713340    ShowControls(Controls)           
    33723341    constrDict,fixedList = GetConstraints(GPXfile)
    3373     restDict = GetRestraints(GPXfile)
     3342    restraintDict = GetRestraints(GPXfile)
    33743343    Histograms,Phases = GetUsedHistogramsAndPhases(GPXfile)
    33753344    if not Phases:
     
    33813350        print ' *** Refine aborted ***'
    33823351        raise Exception
    3383     Natoms,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables = GetPhaseData(Phases,restDict,False)
     3352    Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables = GetPhaseData(Phases,restraintDict,False)
    33843353    if 'Seq Data' in Controls:
    33853354        histNames = Controls['Seq Data']
     
    33963365            dlg.SetTitle('Residual for histogram '+str(ihst))
    33973366        calcControls = {}
     3367        calcControls['atomIndx'] = atomIndx
    33983368        calcControls['Natoms'] = Natoms
    33993369        calcControls['FFtables'] = FFtables
     
    34593429                result = so.leastsq(errRefine,values,Dfun=dervRefine,full_output=True,
    34603430                    ftol=Ftol,col_deriv=True,factor=Factor,
    3461                     args=([Histo,Phases,restDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
     3431                    args=([Histo,Phases,restraintDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
    34623432                ncyc = int(result[2]['nfev']/2)
    34633433            elif 'Hessian' in Controls['deriv type']:
    34643434                result = G2mth.HessianLSQ(errRefine,values,Hess=HessRefine,ftol=Ftol,maxcyc=maxCyc,
    3465                     args=([Histo,Phases,restDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
     3435                    args=([Histo,Phases,restraintDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
    34663436                ncyc = result[2]['num cyc']+1                           
    34673437            else:           #'numeric'
    34683438                result = so.leastsq(errRefine,values,full_output=True,ftol=Ftol,epsfcn=1.e-8,factor=Factor,
    3469                     args=([Histo,Phases,restDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
     3439                    args=([Histo,Phases,restraintDict],parmDict,varyList,calcControls,pawleyLookup,dlg))
    34703440                ncyc = int(result[2]['nfev']/len(varyList))
    34713441
Note: See TracChangeset for help on using the changeset viewer.