def Reader(self, filename, ParentFrame=None, **unused):
'''Read a phase from a .GPX file. Does not (yet?) support selecting and reading
more than one phase at a time.'''
try:
phasenames = G2stIO.GetPhaseNames(filename)
except:
self.errors = 'Reading of phase names failed'
return False
if not phasenames:
self.errors = 'No phases found in ' + str(filename)
return False # no blocks with coordinates
elif len(phasenames) == 1: # one block, no choices
selblk = 0
else: # choose from options
selblk = G2IO.PhaseSelector(
phasenames,
ParentFrame=ParentFrame,
title='Select a phase from the list below',
)
if selblk is None:
self.errors = 'No phase selected'
return False # User pressed cancel
self.Phase = G2stIO.GetAllPhaseData(filename, phasenames[selblk])
self.Phase['Histograms'] = {} #remove any histograms
self.Phase['Pawley ref'] = [] # & any Pawley refl.
self.Phase['RBModels'] = {}
if 'MCSA' in self.Phase:
del self.Phase['MCSA']
if 'Map Peaks' in self.Phase:
del self.Phase['Map Peaks']
if 'Map' in self.Phase['General']:
del self.Phase['General']['Map']
self.Phase['ranId'] = ran.randint(0, sys.maxsize)
return True
def Reader(self, filename, filepointer, ParentFrame=None, **unused):
'''Read a phase from a .GPX file. Does not (yet?) support selecting and reading
more than one phase at a time.'''
try:
phasenames = G2stIO.GetPhaseNames(filename)
except:
self.errors = 'Reading of phase names failed'
return False
if not phasenames:
self.errors = 'No phases found in ' + str(filename)
return False # no blocks with coordinates
elif len(phasenames) == 1: # one block, no choices
selblk = 0
else: # choose from options
selblk = self.PhaseSelector(
phasenames,
ParentFrame=ParentFrame,
title='Select a phase from the list below',
)
if selblk is None:
self.errors = 'No phase selected'
return False # User pressed cancel
try:
self.Phase = G2stIO.GetAllPhaseData(filename, phasenames[selblk])
self.Phase['Histograms'] = {} #remove any histograms
self.Phase['Pawley ref'] = [] # & any Pawley refl.
self.Phase['ranId'] = ran.randint(0, sys.maxint)
return True
except Exception as detail:
self.errors = 'Error reading selected phase'
self.errors += '\n ' + str(detail)
print self.formatName + ' error:', detail # for testing
print sys.exc_info()[0] # for testing
import traceback
print traceback.format_exc()
def _do_refinement(self, gs2):
"""
Calls the refinement routines of the structure module of GSASII
@param gs2 :: the main GSAS-II object
@return residuals, a dictionary that among other parameters contains 'Rwp',
'GOF', 'chisq', and 'converged'
"""
# assume gs2.GSASprojectfile == proj_filename which should be true because
# The project file always needs to be saved before running refine
import GSASIIstrIO
import GSASIIstrMain
err_msg, warn_msg = GSASIIstrIO.ReadCheckConstraints(gs2.GSASprojectfile)
if err_msg:
raise RuntimeError("Error in refinement: {0}".format(err_msg))
if warn_msg:
raise RuntimeError("Conflict between refinement flag settings "
"and constraints: {0}".format(err_msg))
# note: if result_ok==False, residuals is actually an error message text!
result_ok, residuals = GSASIIstrMain.Refine(gs2.GSASprojectfile, dlg=None, useDlg=False)
if not result_ok:
raise RuntimeError("There was a problem while running the core refinement routine. "
"Error description: {0}".format(residuals))
else:
self.log().notice("Refinement routine finished successfully with Rwp (weighted) "
"profile R-factor: {0}".format(residuals['Rwp']))
return residuals
def __init__(self, GPXfile=None):
'''
Initialize the setup using an existing GPXfile
'''
if not GPXfile:
# TO DO: Raise name error
raise NameError('Must input some GPX file')
# Initallizing variables from input file GPXfile
G2path.SetBinaryPath()
varyList = []
parmDict = {}
symmetry = {}
Controls = G2stIO.GetControls(GPXfile)
calcControls = {}
calcControls.update(Controls)
constrDict, fixedList = G2stIO.GetConstraints(GPXfile)
restraintDict = G2stIO.GetRestraints(GPXfile)
Histograms, Phases = G2stIO.GetUsedHistogramsAndPhases(GPXfile)
rigidbodyDict = G2stIO.GetRigidBodies(GPXfile)
rbIds = rigidbodyDict.get('RBIds', {'Vector': [], 'Residue': []})
rbVary, rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict, Print=False)
(Natoms, atomIndx, phaseVary, phaseDict, pawleyLookup, FFtables,
BLtables, MFtables, maxSSwave) = G2stIO.GetPhaseData(Phases,
restraintDict,
rbIds,
Print=False)
calcControls['atomIndx'] = atomIndx
calcControls['Natoms'] = Natoms
calcControls['FFtables'] = FFtables
calcControls['BLtables'] = BLtables
calcControls['MFtables'] = MFtables
calcControls['maxSSwave'] = maxSSwave
hapVary, hapDict, controlDict = G2stIO.GetHistogramPhaseData(
Phases, Histograms, Print=False)
calcControls.update(controlDict)
histVary, histDict, controlDict = G2stIO.GetHistogramData(Histograms,
Print=False)
calcControls.update(controlDict)
varyList = rbVary + phaseVary + hapVary + histVary
parmDict.update(rbDict)
parmDict.update(phaseDict)
parmDict.update(hapDict)
parmDict.update(histDict)
G2stIO.GetFprime(calcControls, Histograms)
# define phase symmetries, currently only works for one phase
phase = G2stIO.GetPhaseNames(GPXfile)
phaseData = {}
for name in phase:
phaseData[name] = G2stIO.GetAllPhaseData(GPXfile, name)
symmetry[name] = phaseData[name]['General']['SGData']['SGSys']
# Save the instance parameters
self._Histograms = Histograms
self._varyList = varyList
self._parmDict = parmDict
self._Phases = Phases
self._calcControls = calcControls
self._pawleyLookup = pawleyLookup
self._restraintDict = restraintDict
self._rigidbodyDict = rigidbodyDict
self._rbIds = rbIds
self._symmetry = symmetry
self._phase = phase
try:
self._lowerLimit = Histograms[list(
Histograms.keys())[0]][u'Limits'][1][0]
self._upperLimit = Histograms[list(
Histograms.keys())[0]][u'Limits'][1][1]
self._tth = Histograms[list(Histograms.keys())[0]]['Data'][0][0:-1]
self._tthsample = self._tth[np.where(
(self._tth > self._lowerLimit)
& (self._tth < self._upperLimit) == True)] # noqa: E712
self._SingleXtal = False
except: # noqa: E722
self._tth = None
self._MaxDiffSig = None
self._Fosq = 0
self._FoSig = 0
self._Fcsq = 0
self._SingleXtal = True
def PrintDistAngle(DisAglCtls,DisAglData,out=sys.stdout):
'''Print distances and angles
:param dict DisAglCtls: contains distance/angle radii usually defined using
:func:`GSASIIctrlGUI.DisAglDialog`
:param dict DisAglData: contains phase data:
Items 'OrigAtoms' and 'TargAtoms' contain the atoms to be used
for distance/angle origins and atoms to be used as targets.
Item 'SGData' has the space group information (see :ref:`Space Group object<SGData_table>`)
:param file out: file object for output. Defaults to sys.stdout.
'''
def MyPrint(s):
out.write(s+'\n')
# print(s,file=out) # use in Python 3
def ShowBanner(name):
MyPrint(80*'*')
MyPrint(' Interatomic Distances and Angles for phase '+name)
MyPrint((80*'*')+'\n')
ShowBanner(DisAglCtls['Name'])
SGData = DisAglData['SGData']
SGtext,SGtable = G2spc.SGPrint(SGData)
for line in SGtext: MyPrint(line)
if len(SGtable) > 1:
for i,item in enumerate(SGtable[::2]):
if 2*i+1 == len(SGtable):
line = ' %s'%(item.ljust(30))
else:
line = ' %s %s'%(item.ljust(30),SGtable[2*i+1].ljust(30))
MyPrint(line)
else:
MyPrint(' ( 1) %s'%(SGtable[0])) #triclinic case
Cell = DisAglData['Cell']
Amat,Bmat = G2lat.cell2AB(Cell[:6])
covData = {}
if 'covData' in DisAglData:
covData = DisAglData['covData']
pfx = str(DisAglData['pId'])+'::'
A = G2lat.cell2A(Cell[:6])
cellSig = G2stIO.getCellEsd(pfx,SGData,A,covData)
names = [' a = ',' b = ',' c = ',' alpha = ',' beta = ',' gamma = ',' Volume = ']
valEsd = [G2mth.ValEsd(Cell[i],cellSig[i],True) for i in range(7)]
line = '\n Unit cell:'
for name,vals in zip(names,valEsd):
line += name+vals
MyPrint(line)
else:
MyPrint('\n Unit cell: a = '+('%.5f'%Cell[0])+' b = '+('%.5f'%Cell[1])+' c = '+('%.5f'%Cell[2])+
' alpha = '+('%.3f'%Cell[3])+' beta = '+('%.3f'%Cell[4])+' gamma = '+
('%.3f'%Cell[5])+' Volume = '+('%.3f'%Cell[6]))
AtomLabels,DistArray,AngArray = RetDistAngle(DisAglCtls,DisAglData)
origAtoms = DisAglData['OrigAtoms']
for Oatom in origAtoms:
i = Oatom[0]
Dist = DistArray[i]
nDist = len(Dist)
angles = np.zeros((nDist,nDist))
angsig = np.zeros((nDist,nDist))
for k,j,tup in AngArray[i]:
angles[k][j],angsig[k][j] = angles[j][k],angsig[j][k] = tup
line = ''
for i,x in enumerate(Oatom[3:6]):
line += ('%12.5f'%x).rstrip('0')
MyPrint('\n Distances & angles for '+Oatom[1]+' at '+line.rstrip())
MyPrint(80*'*')
line = ''
for dist in Dist[:-1]:
line += '%12s'%(AtomLabels[dist[0]].center(12))
MyPrint(' To cell +(sym. op.) dist. '+line.rstrip())
for i,dist in enumerate(Dist):
line = ''
for j,angle in enumerate(angles[i][0:i]):
sig = angsig[i][j]
if angle:
if sig:
line += '%12s'%(G2mth.ValEsd(angle,sig,True).center(12))
else:
val = '%.3f'%(angle)
line += '%12s'%(val.center(12))
else:
line += 12*' '
if dist[4]: #sig exists!
val = G2mth.ValEsd(dist[3],dist[4])
else:
val = '%8.4f'%(dist[3])
tunit = '[%2d%2d%2d]'% dist[1]
MyPrint((' %8s%10s+(%4d) %12s'%(AtomLabels[dist[0]].ljust(8),tunit.ljust(10),dist[2],val.center(12)))+line.rstrip())
def SeqRefine(GPXfile,dlg,refPlotUpdate=None):
'''Perform a sequential refinement -- cycles through all selected histgrams,
one at a time
'''
import GSASIImpsubs as G2mp
G2mp.InitMP()
import pytexture as ptx
ptx.pyqlmninit() #initialize fortran arrays for spherical harmonics
printFile = open(ospath.splitext(GPXfile)[0]+'.lst','w')
G2fil.G2Print ('Starting Sequential Refinement')
G2stIO.ShowBanner(printFile)
Controls = G2stIO.GetControls(GPXfile)
G2stIO.ShowControls(Controls,printFile,SeqRef=True)
restraintDict = G2stIO.GetRestraints(GPXfile)
Histograms,Phases = G2stIO.GetUsedHistogramsAndPhases(GPXfile)
if not Phases:
G2fil.G2Print (' *** ERROR - you have no phases to refine! ***')
G2fil.G2Print (' *** Refine aborted ***')
return False,'No phases'
if not Histograms:
G2fil.G2Print (' *** ERROR - you have no data to refine with! ***')
G2fil.G2Print (' *** Refine aborted ***')
return False,'No data'
rigidbodyDict = G2stIO.GetRigidBodies(GPXfile)
rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,pFile=printFile)
G2mv.InitVars()
(Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables,MFtables,
maxSSwave) = G2stIO.GetPhaseData(Phases,restraintDict,rbIds,
Print=False,pFile=printFile,seqRef=True)
for item in phaseVary:
if '::A0' in item:
G2fil.G2Print ('**** WARNING - lattice parameters should not be refined in a sequential refinement ****')
G2fil.G2Print ('**** instead use the Dij parameters for each powder histogram ****')
return False,'Lattice parameter refinement error - see console message'
if '::C(' in item:
G2fil.G2Print ('**** WARNING - phase texture parameters should not be refined in a sequential refinement ****')
G2fil.G2Print ('**** instead use the C(L,N) parameters for each powder histogram ****')
return False,'Phase texture refinement error - see console message'
if 'Seq Data' in Controls:
histNames = Controls['Seq Data']
else: # patch from before Controls['Seq Data'] was implemented?
histNames = G2stIO.GetHistogramNames(GPXfile,['PWDR',])
if Controls.get('Reverse Seq'):
histNames.reverse()
SeqResult = G2stIO.GetSeqResult(GPXfile)
# SeqResult = {'SeqPseudoVars':{},'SeqParFitEqList':[]}
Histo = {}
NewparmDict = {}
G2stIO.SetupSeqSavePhases(GPXfile)
for ihst,histogram in enumerate(histNames):
if GSASIIpath.GetConfigValue('Show_timing'): t1 = time.time()
G2fil.G2Print('\nRefining with '+str(histogram))
G2mv.InitVars()
(Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,
FFtables,BLtables,MFtables,maxSSwave) = G2stIO.GetPhaseData(
Phases,restraintDict,rbIds,
Print=False,pFile=printFile,seqRef=True)
ifPrint = False
if dlg:
dlg.SetTitle('Residual for histogram '+str(ihst))
calcControls = {}
calcControls['atomIndx'] = atomIndx
calcControls['Natoms'] = Natoms
calcControls['FFtables'] = FFtables
calcControls['BLtables'] = BLtables
calcControls['MFtables'] = MFtables
calcControls['maxSSwave'] = maxSSwave
if histogram not in Histograms:
G2fil.G2Print("Error: not found!")
continue
#TODO - implement "Fix FXU" for seq refinement here - done?
hId = Histograms[histogram]['hId']
redphaseVary = phaseCheck(phaseVary,Phases,histogram)
Histo = {histogram:Histograms[histogram],}
hapVary,hapDict,controlDict = G2stIO.GetHistogramPhaseData(Phases,Histo,Print=False)
calcControls.update(controlDict)
histVary,histDict,controlDict = G2stIO.GetHistogramData(Histo,False)
calcControls.update(controlDict)
varyList = rbVary+redphaseVary+hapVary+histVary
# if not ihst:
# save the initial vary list, but without histogram numbers on parameters
saveVaryList = varyList[:]
for i,item in enumerate(saveVaryList):
items = item.split(':')
if items[1]:
items[1] = ''
item = ':'.join(items)
saveVaryList[i] = item
if not ihst:
SeqResult['varyList'] = saveVaryList
else:
SeqResult['varyList'] = list(set(SeqResult['varyList']+saveVaryList))
parmDict = {}
parmDict.update(rbDict)
parmDict.update(phaseDict)
parmDict.update(hapDict)
parmDict.update(histDict)
if Controls['Copy2Next']: # update with parms from last histogram
#parmDict.update(NewparmDict) # don't use in case extra entries would cause a problem
for parm in NewparmDict:
if parm in parmDict:
parmDict[parm] = NewparmDict[parm]
elif histogram in SeqResult: # update phase from last seq ref
NewparmDict = SeqResult[histogram].get('parmDict',{})
for parm in NewparmDict:
if '::' in parm and parm in parmDict:
parmDict[parm] = NewparmDict[parm]
G2stIO.GetFprime(calcControls,Histo)
# do constraint processing
#reload(G2mv) # debug
constrDict,fixedList = G2stIO.GetConstraints(GPXfile)
varyListStart = tuple(varyList) # save the original varyList before dependent vars are removed
msg = G2mv.EvaluateMultipliers(constrDict,parmDict)
if msg:
return False,'Unable to interpret multiplier(s): '+msg
try:
groups,parmlist = G2mv.GenerateConstraints(varyList,constrDict,fixedList,parmDict,SeqHist=hId)
# if GSASIIpath.GetConfigValue('debug'): print("DBG_"+
# G2mv.VarRemapShow(varyList,True))
# print('DependentVars',G2mv.GetDependentVars())
# print('IndependentVars',G2mv.GetIndependentVars())
constraintInfo = (groups,parmlist,constrDict,fixedList,ihst)
except G2mv.ConstraintException:
G2fil.G2Print (' *** ERROR - your constraints are internally inconsistent ***')
#errmsg, warnmsg = G2mv.CheckConstraints(varyList,constrDict,fixedList)
#print 'Errors',errmsg
#if warnmsg: print 'Warnings',warnmsg
return False,' Constraint error'
#print G2mv.VarRemapShow(varyList)
if not ihst:
# first histogram to refine against
firstVaryList = []
for item in varyList:
items = item.split(':')
if items[1]:
items[1] = ''
item = ':'.join(items)
firstVaryList.append(item)
newVaryList = firstVaryList
else:
newVaryList = []
for item in varyList:
items = item.split(':')
if items[1]:
items[1] = ''
item = ':'.join(items)
newVaryList.append(item)
if newVaryList != firstVaryList and Controls['Copy2Next']:
# variable lists are expected to match between sequential refinements when Copy2Next is on
#print '**** ERROR - variable list for this histogram does not match previous'
#print ' Copy of variables is not possible'
#print '\ncurrent histogram',histogram,'has',len(newVaryList),'variables'
combined = list(set(firstVaryList+newVaryList))
c = [var for var in combined if var not in newVaryList]
p = [var for var in combined if var not in firstVaryList]
G2fil.G2Print('*** Variables change ***')
for typ,vars in [('Removed',c),('Added',p)]:
line = ' '+typ+': '
if vars:
for var in vars:
if len(line) > 70:
G2fil.G2Print(line)
line = ' '
line += var + ', '
else:
line += 'none, '
G2fil.G2Print(line[:-2])
firstVaryList = newVaryList
ifSeq = True
printFile.write('\n Refinement results for histogram: %s\n'%histogram)
printFile.write(135*'-'+'\n')
try:
IfOK,Rvals,result,covMatrix,sig = RefineCore(Controls,Histo,Phases,restraintDict,
rigidbodyDict,parmDict,varyList,calcControls,pawleyLookup,ifSeq,printFile,dlg,
refPlotUpdate=refPlotUpdate)
G2fil.G2Print (' wR = %7.2f%%, chi**2 = %12.6g, reduced chi**2 = %6.2f, last delta chi = %.4f'%(
Rvals['Rwp'],Rvals['chisq'],Rvals['GOF']**2,Rvals['DelChi2']))
# add the uncertainties into the esd dictionary (sigDict)
if not IfOK:
G2fil.G2Print('***** Sequential refinement failed at histogram '+histogram,mode='warn')
break
sigDict = dict(zip(varyList,sig))
# the uncertainties for dependent constrained parms into the esd dict
sigDict.update(G2mv.ComputeDepESD(covMatrix,varyList,parmDict))
# a dict with values & esds for dependent (constrained) parameters - avoid extraneous holds
depParmDict = {i:(parmDict[i],sigDict[i]) for i in varyListStart if i in sigDict and i not in varyList}
newCellDict = copy.deepcopy(G2stMth.GetNewCellParms(parmDict,varyList))
newAtomDict = copy.deepcopy(G2stMth.ApplyXYZshifts(parmDict,varyList))
histRefData = {
'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
'varyListStart':varyListStart,
'covMatrix':covMatrix,'title':histogram,'newAtomDict':newAtomDict,
'newCellDict':newCellDict,'depParmDict':depParmDict,
'constraintInfo':constraintInfo,
'parmDict':parmDict}
SeqResult[histogram] = histRefData
G2stMth.ApplyRBModels(parmDict,Phases,rigidbodyDict,True)
# G2stIO.SetRigidBodyModels(parmDict,sigDict,rigidbodyDict,printFile)
G2stIO.SetHistogramPhaseData(parmDict,sigDict,Phases,Histo,None,ifPrint,printFile)
G2stIO.SetHistogramData(parmDict,sigDict,Histo,None,ifPrint,printFile)
G2stIO.SaveUpdatedHistogramsAndPhases(GPXfile,Histo,Phases,rigidbodyDict,histRefData)
NewparmDict = {}
# make dict of varied parameters in current histogram, renamed to
# next histogram, for use in next refinement.
if Controls['Copy2Next'] and ihst < len(histNames)-1:
hId = Histo[histogram]['hId'] # current histogram
nexthId = Histograms[histNames[ihst+1]]['hId']
for parm in set(list(varyList)+list(varyListStart)):
items = parm.split(':')
if len(items) < 3:
continue
if str(hId) in items[1]:
items[1] = str(nexthId)
newparm = ':'.join(items)
NewparmDict[newparm] = parmDict[parm]
else:
if items[2].startswith('dA'): parm = parm.replace(':dA',':A')
NewparmDict[parm] = parmDict[parm]
except G2obj.G2RefineCancel as Msg:
printFile.close()
G2fil.G2Print (' ***** Refinement stopped *****')
return False,Msg.msg
except G2obj.G2Exception as Msg: # cell metric error, others?
printFile.close()
G2fil.G2Print (' ***** Refinement error *****')
return False,Msg.msg
if GSASIIpath.GetConfigValue('Show_timing'):
t2 = time.time()
G2fil.G2Print("Fit step time {:.2f} sec.".format(t2-t1))
t1 = t2
SeqResult['histNames'] = [itm for itm in G2stIO.GetHistogramNames(GPXfile,['PWDR',]) if itm in SeqResult.keys()]
G2stIO.SetSeqResult(GPXfile,Histograms,SeqResult)
printFile.close()
G2fil.G2Print (' Sequential refinement results are in file: '+ospath.splitext(GPXfile)[0]+'.lst')
G2fil.G2Print (' ***** Sequential refinement successful *****')
return True,'Success'
def Refine(GPXfile,dlg=None,makeBack=True,refPlotUpdate=None):
'Global refinement -- refines to minimize against all histograms'
import GSASIImpsubs as G2mp
G2mp.InitMP()
import pytexture as ptx
ptx.pyqlmninit() #initialize fortran arrays for spherical harmonics
printFile = open(ospath.splitext(GPXfile)[0]+'.lst','w')
G2stIO.ShowBanner(printFile)
varyList = []
parmDict = {}
G2mv.InitVars()
Controls = G2stIO.GetControls(GPXfile)
G2stIO.ShowControls(Controls,printFile)
calcControls = {}
calcControls.update(Controls)
constrDict,fixedList = G2stIO.GetConstraints(GPXfile)
restraintDict = G2stIO.GetRestraints(GPXfile)
Histograms,Phases = G2stIO.GetUsedHistogramsAndPhases(GPXfile)
if not Phases:
G2fil.G2Print (' *** ERROR - you have no phases to refine! ***')
G2fil.G2Print (' *** Refine aborted ***')
return False,'No phases'
if not Histograms:
G2fil.G2Print (' *** ERROR - you have no data to refine with! ***')
G2fil.G2Print (' *** Refine aborted ***')
return False,'No data'
rigidbodyDict = G2stIO.GetRigidBodies(GPXfile)
rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,pFile=printFile)
(Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables,MFtables,
maxSSwave) = G2stIO.GetPhaseData(Phases,restraintDict,rbIds,pFile=printFile)
calcControls['atomIndx'] = atomIndx
calcControls['Natoms'] = Natoms
calcControls['FFtables'] = FFtables
calcControls['BLtables'] = BLtables
calcControls['MFtables'] = MFtables
calcControls['maxSSwave'] = maxSSwave
hapVary,hapDict,controlDict = G2stIO.GetHistogramPhaseData(Phases,Histograms,pFile=printFile)
TwConstr,TwFixed = G2stIO.makeTwinFrConstr(Phases,Histograms,hapVary)
constrDict += TwConstr
fixedList += TwFixed
calcControls.update(controlDict)
histVary,histDict,controlDict = G2stIO.GetHistogramData(Histograms,pFile=printFile)
calcControls.update(controlDict)
varyList = rbVary+phaseVary+hapVary+histVary
parmDict.update(rbDict)
parmDict.update(phaseDict)
parmDict.update(hapDict)
parmDict.update(histDict)
G2stIO.GetFprime(calcControls,Histograms)
# do constraint processing
varyListStart = tuple(varyList) # save the original varyList before dependent vars are removed
msg = G2mv.EvaluateMultipliers(constrDict,parmDict)
if msg:
return False,'Unable to interpret multiplier(s): '+msg
try:
G2mv.GenerateConstraints(varyList,constrDict,fixedList,parmDict)
#print(G2mv.VarRemapShow(varyList))
#print('DependentVars',G2mv.GetDependentVars())
#print('IndependentVars',G2mv.GetIndependentVars())
except G2mv.ConstraintException:
G2fil.G2Print (' *** ERROR - your constraints are internally inconsistent ***')
#errmsg, warnmsg = G2mv.CheckConstraints(varyList,constrDict,fixedList)
#print 'Errors',errmsg
#if warnmsg: print 'Warnings',warnmsg
return False,' Constraint error'
# print G2mv.VarRemapShow(varyList)
ifSeq = False
printFile.write('\n Refinement results:\n')
printFile.write(135*'-'+'\n')
try:
covData = {}
IfOK,Rvals,result,covMatrix,sig = RefineCore(Controls,Histograms,Phases,restraintDict,
rigidbodyDict,parmDict,varyList,calcControls,pawleyLookup,ifSeq,printFile,dlg,
refPlotUpdate=refPlotUpdate)
if IfOK:
sigDict = dict(zip(varyList,sig))
newCellDict = G2stMth.GetNewCellParms(parmDict,varyList)
newAtomDict = G2stMth.ApplyXYZshifts(parmDict,varyList)
covData = {'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
'varyListStart':varyListStart,
'covMatrix':covMatrix,'title':GPXfile,'newAtomDict':newAtomDict,
'newCellDict':newCellDict,'freshCOV':True}
# add the uncertainties into the esd dictionary (sigDict)
sigDict.update(G2mv.ComputeDepESD(covMatrix,varyList,parmDict))
G2mv.PrintIndependentVars(parmDict,varyList,sigDict,pFile=printFile)
G2stMth.ApplyRBModels(parmDict,Phases,rigidbodyDict,True)
G2stIO.SetRigidBodyModels(parmDict,sigDict,rigidbodyDict,printFile)
G2stIO.SetPhaseData(parmDict,sigDict,Phases,rbIds,covData,restraintDict,printFile)
G2stIO.SetHistogramPhaseData(parmDict,sigDict,Phases,Histograms,calcControls['FFtables'],pFile=printFile)
G2stIO.SetHistogramData(parmDict,sigDict,Histograms,calcControls['FFtables'],pFile=printFile)
G2stIO.SetUsedHistogramsAndPhases(GPXfile,Histograms,Phases,rigidbodyDict,covData,makeBack)
printFile.close()
G2fil.G2Print (' Refinement results are in file: '+ospath.splitext(GPXfile)[0]+'.lst')
G2fil.G2Print (' ***** Refinement successful *****')
else:
G2fil.G2Print ('****ERROR - Refinement failed')
raise G2obj.G2Exception('****ERROR - Refinement failed')
except G2obj.G2RefineCancel as Msg:
printFile.close()
G2fil.G2Print (' ***** Refinement stopped *****')
return False,Msg.msg
except G2obj.G2Exception as Msg: # cell metric error, others?
printFile.close()
G2fil.G2Print (' ***** Refinement error *****')
return False,Msg.msg
#for testing purposes, create a file for testderiv
if GSASIIpath.GetConfigValue('debug'): # and IfOK:
#needs: values,HistoPhases,parmDict,varylist,calcControls,pawleyLookup
fl = open(ospath.splitext(GPXfile)[0]+'.testDeriv','wb')
cPickle.dump(result[0],fl,1)
cPickle.dump([Histograms,Phases,restraintDict,rigidbodyDict],fl,1)
cPickle.dump([constrDict,fixedList,G2mv.GetDependentVars()],fl,1)
cPickle.dump(parmDict,fl,1)
cPickle.dump(varyList,fl,1)
cPickle.dump(calcControls,fl,1)
cPickle.dump(pawleyLookup,fl,1)
fl.close()
if dlg:
return True,Rvals
def PrintDistAngle(DisAglCtls,DisAglData,out=sys.stdout):
'''Print distances and angles
:param dict DisAglCtls: contains distance/angle radii usually defined using
:func:`GSASIIgrid.DisAglDialog`
:param dict DisAglData: contains phase data:
Items 'OrigAtoms' and 'TargAtoms' contain the atoms to be used
for distance/angle origins and atoms to be used as targets.
Item 'SGData' has the space group information (see :ref:`Space Group object<SGData_table>`)
:param file out: file object for output. Defaults to sys.stdout.
'''
import numpy.ma as ma
def MyPrint(s):
out.write(s+'\n')
# print(s,file=out) # use in Python 3
def ShowBanner(name):
MyPrint(80*'*')
MyPrint(' Interatomic Distances and Angles for phase '+name)
MyPrint((80*'*')+'\n')
ShowBanner(DisAglCtls['Name'])
SGData = DisAglData['SGData']
SGtext,SGtable = G2spc.SGPrint(SGData)
for line in SGtext: MyPrint(line)
if len(SGtable):
for i,item in enumerate(SGtable[::2]):
line = ' %s %s'%(item.ljust(30),SGtable[2*i+1].ljust(30))
MyPrint(line)
else:
MyPrint(' ( 1) %s'%(SGtable[0]))
Cell = DisAglData['Cell']
Amat,Bmat = G2lat.cell2AB(Cell[:6])
covData = {}
if 'covData' in DisAglData:
covData = DisAglData['covData']
covMatrix = covData['covMatrix']
varyList = covData['varyList']
pfx = str(DisAglData['pId'])+'::'
A = G2lat.cell2A(Cell[:6])
cellSig = G2stIO.getCellEsd(pfx,SGData,A,covData)
names = [' a = ',' b = ',' c = ',' alpha = ',' beta = ',' gamma = ',' Volume = ']
valEsd = [G2mth.ValEsd(Cell[i],cellSig[i],True) for i in range(7)]
line = '\n Unit cell:'
for name,vals in zip(names,valEsd):
line += name+vals
MyPrint(line)
else:
MyPrint('\n Unit cell: a = '+('%.5f'%Cell[0])+' b = '+('%.5f'%Cell[1])+' c = '+('%.5f'%Cell[2])+
' alpha = '+('%.3f'%Cell[3])+' beta = '+('%.3f'%Cell[4])+' gamma = '+
('%.3f'%Cell[5])+' volume = '+('%.3f'%Cell[6]))
AtomLabels,DistArray,AngArray = RetDistAngle(DisAglCtls,DisAglData)
origAtoms = DisAglData['OrigAtoms']
targAtoms = DisAglData['TargAtoms']
for Oatom in origAtoms:
i = Oatom[0]
Dist = DistArray[i]
nDist = len(Dist)
angles = np.zeros((nDist,nDist))
angsig = np.zeros((nDist,nDist))
for k,j,tup in AngArray[i]:
angles[k][j],angsig[k][j] = angles[j][k],angsig[j][k] = tup
line = ''
for i,x in enumerate(Oatom[3:6]):
line += ('%12.5f'%x).rstrip('0')
MyPrint('\n Distances & angles for '+Oatom[1]+' at '+line.rstrip())
MyPrint(80*'*')
line = ''
for dist in Dist[:-1]:
line += '%12s'%(AtomLabels[dist[0]].center(12))
MyPrint(' To cell +(sym. op.) dist. '+line.rstrip())
for i,dist in enumerate(Dist):
line = ''
for j,angle in enumerate(angles[i][0:i]):
sig = angsig[i][j]
if angle:
if sig:
line += '%12s'%(G2mth.ValEsd(angle,sig,True).center(12))
else:
val = '%.3f'%(angle)
line += '%12s'%(val.center(12))
else:
line += 12*' '
if dist[4]: #sig exists!
val = G2mth.ValEsd(dist[3],dist[4])
else:
val = '%8.4f'%(dist[3])
tunit = '[%2d%2d%2d]'% dist[1]
MyPrint((' %8s%10s+(%4d) %12s'%(AtomLabels[dist[0]].ljust(8),tunit.ljust(10),dist[2],val.center(12)))+line.rstrip())
def RetDistAngle(DisAglCtls,DisAglData):
'''Compute and return distances and angles
:param dict DisAglCtls: contains distance/angle radii usually defined using
:func:`GSASIIgrid.DisAglDialog`
:param dict DisAglData: contains phase data:
Items 'OrigAtoms' and 'TargAtoms' contain the atoms to be used
for distance/angle origins and atoms to be used as targets.
Item 'SGData' has the space group information (see :ref:`Space Group object<SGData_table>`)
:returns: AtomLabels,DistArray,AngArray where:
**AtomLabels** is a dict of atom labels, keys are the atom number
**DistArray** is a dict keyed by the origin atom number where the value is a list
of distance entries. The value for each distance is a list containing:
0) the target atom number (int);
1) the unit cell offsets added to x,y & z (tuple of int values)
2) the symmetry operator number (which may be modified to indicate centering and center of symmetry)
3) an interatomic distance in A (float)
4) an uncertainty on the distance in A or 0.0 (float)
**AngArray** is a dict keyed by the origin (central) atom number where
the value is a list of
angle entries. The value for each angle entry consists of three values:
0) a distance item reference for one neighbor (int)
1) a distance item reference for a second neighbor (int)
2) a angle, uncertainty pair; the s.u. may be zero (tuple of two floats)
The AngArray distance reference items refer directly to the index of the items in the
DistArray item for the list of distances for the central atom.
'''
import numpy.ma as ma
SGData = DisAglData['SGData']
Cell = DisAglData['Cell']
Amat,Bmat = G2lat.cell2AB(Cell[:6])
covData = {}
if 'covData' in DisAglData:
covData = DisAglData['covData']
covMatrix = covData['covMatrix']
varyList = covData['varyList']
pfx = str(DisAglData['pId'])+'::'
A = G2lat.cell2A(Cell[:6])
cellSig = G2stIO.getCellEsd(pfx,SGData,A,covData)
names = [' a = ',' b = ',' c = ',' alpha = ',' beta = ',' gamma = ',' Volume = ']
valEsd = [G2mth.ValEsd(Cell[i],cellSig[i],True) for i in range(7)]
Factor = DisAglCtls['Factors']
Radii = dict(zip(DisAglCtls['AtomTypes'],zip(DisAglCtls['BondRadii'],DisAglCtls['AngleRadii'])))
indices = (-1,0,1)
Units = np.array([[h,k,l] for h in indices for k in indices for l in indices])
origAtoms = DisAglData['OrigAtoms']
targAtoms = DisAglData['TargAtoms']
AtomLabels = {}
for Oatom in origAtoms:
AtomLabels[Oatom[0]] = Oatom[1]
for Oatom in targAtoms:
AtomLabels[Oatom[0]] = Oatom[1]
DistArray = {}
AngArray = {}
for Oatom in origAtoms:
DistArray[Oatom[0]] = []
AngArray[Oatom[0]] = []
OxyzNames = ''
IndBlist = []
Dist = []
Vect = []
VectA = []
angles = []
for Tatom in targAtoms:
Xvcov = []
TxyzNames = ''
if 'covData' in DisAglData:
OxyzNames = [pfx+'dAx:%d'%(Oatom[0]),pfx+'dAy:%d'%(Oatom[0]),pfx+'dAz:%d'%(Oatom[0])]
TxyzNames = [pfx+'dAx:%d'%(Tatom[0]),pfx+'dAy:%d'%(Tatom[0]),pfx+'dAz:%d'%(Tatom[0])]
Xvcov = G2mth.getVCov(OxyzNames+TxyzNames,varyList,covMatrix)
result = G2spc.GenAtom(Tatom[3:6],SGData,False,Move=False)
BsumR = (Radii[Oatom[2]][0]+Radii[Tatom[2]][0])*Factor[0]
AsumR = (Radii[Oatom[2]][1]+Radii[Tatom[2]][1])*Factor[1]
for Txyz,Top,Tunit in result:
Dx = (Txyz-np.array(Oatom[3:6]))+Units
dx = np.inner(Amat,Dx)
dist = ma.masked_less(np.sqrt(np.sum(dx**2,axis=0)),0.5)
IndB = ma.nonzero(ma.masked_greater(dist-BsumR,0.))
if np.any(IndB):
for indb in IndB:
for i in range(len(indb)):
if str(dx.T[indb][i]) not in IndBlist:
IndBlist.append(str(dx.T[indb][i]))
unit = Units[indb][i]
tunit = (unit[0]+Tunit[0],unit[1]+Tunit[1],unit[2]+Tunit[2])
pdpx = G2mth.getDistDerv(Oatom[3:6],Tatom[3:6],Amat,unit,Top,SGData)
sig = 0.0
if len(Xvcov):
sig = np.sqrt(np.inner(pdpx,np.inner(Xvcov,pdpx)))
Dist.append([Oatom[0],Tatom[0],tunit,Top,ma.getdata(dist[indb])[i],sig])
if (Dist[-1][-2]-AsumR) <= 0.:
Vect.append(dx.T[indb][i]/Dist[-1][-2])
VectA.append([OxyzNames,np.array(Oatom[3:6]),TxyzNames,np.array(Tatom[3:6]),unit,Top])
else:
Vect.append([0.,0.,0.])
VectA.append([])
for D in Dist:
DistArray[Oatom[0]].append(D[1:])
Vect = np.array(Vect)
angles = np.zeros((len(Vect),len(Vect)))
angsig = np.zeros((len(Vect),len(Vect)))
for i,veca in enumerate(Vect):
if np.any(veca):
for j,vecb in enumerate(Vect):
if np.any(vecb):
angles[i][j],angsig[i][j] = G2mth.getAngSig(VectA[i],VectA[j],Amat,SGData,covData)
if i <= j: continue
AngArray[Oatom[0]].append((i,j,
G2mth.getAngSig(VectA[i],VectA[j],Amat,SGData,covData)))
return AtomLabels,DistArray,AngArray
def SeqRefine(GPXfile,dlg):
'''Perform a sequential refinement -- cycles through all selected histgrams,
one at a time
'''
import pytexture as ptx
ptx.pyqlmninit() #initialize fortran arrays for spherical harmonics
printFile = open(ospath.splitext(GPXfile)[0]+'.lst','w')
print 'Starting Sequential Refinement'
G2stIO.ShowBanner(printFile)
Controls = G2stIO.GetControls(GPXfile)
G2stIO.ShowControls(Controls,printFile,SeqRef=True)
restraintDict = G2stIO.GetRestraints(GPXfile)
Histograms,Phases = G2stIO.GetUsedHistogramsAndPhases(GPXfile)
if not Phases:
print ' *** ERROR - you have no phases to refine! ***'
print ' *** Refine aborted ***'
return False,'No phases'
if not Histograms:
print ' *** ERROR - you have no data to refine with! ***'
print ' *** Refine aborted ***'
return False,'No data'
rigidbodyDict = G2stIO.GetRigidBodies(GPXfile)
rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,pFile=printFile)
Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables,maxSSwave = G2stIO.GetPhaseData(Phases,restraintDict,rbIds,False,printFile,seqRef=True)
for item in phaseVary:
if '::A0' in item:
print '**** WARNING - lattice parameters should not be refined in a sequential refinement ****'
print '**** instead use the Dij parameters for each powder histogram ****'
return False,'Lattice parameter refinement error - see console message'
if '::C(' in item:
print '**** WARNING - phase texture parameters should not be refined in a sequential refinement ****'
print '**** instead use the C(L,N) parameters for each powder histogram ****'
return False,'Phase texture refinement error - see console message'
if 'Seq Data' in Controls:
histNames = Controls['Seq Data']
else:
histNames = G2stIO.GetHistogramNames(GPXfile,['PWDR',])
if 'Reverse Seq' in Controls:
if Controls['Reverse Seq']:
histNames.reverse()
SeqResult = {'histNames':histNames}
makeBack = True
Histo = {}
NewparmDict = {}
for ihst,histogram in enumerate(histNames):
print('Refining with '+str(histogram))
ifPrint = False
if dlg:
dlg.SetTitle('Residual for histogram '+str(ihst))
calcControls = {}
calcControls['atomIndx'] = atomIndx
calcControls['Natoms'] = Natoms
calcControls['FFtables'] = FFtables
calcControls['BLtables'] = BLtables
calcControls['maxSSwave'] = maxSSwave
Histo = {histogram:Histograms[histogram],}
hapVary,hapDict,controlDict = G2stIO.GetHistogramPhaseData(Phases,Histo,Print=False)
calcControls.update(controlDict)
histVary,histDict,controlDict = G2stIO.GetHistogramData(Histo,False)
calcControls.update(controlDict)
varyList = rbVary+phaseVary+hapVary+histVary
if not ihst:
# save the initial vary list, but without histogram numbers on parameters
saveVaryList = varyList[:]
for i,item in enumerate(saveVaryList):
items = item.split(':')
if items[1]:
items[1] = ''
item = ':'.join(items)
saveVaryList[i] = item
SeqResult['varyList'] = saveVaryList
origvaryList = varyList[:]
parmDict = {}
parmDict.update(phaseDict)
parmDict.update(hapDict)
parmDict.update(histDict)
if Controls['Copy2Next']:
parmDict.update(NewparmDict)
G2stIO.GetFprime(calcControls,Histo)
# do constraint processing
#reload(G2mv) # debug
G2mv.InitVars()
constrDict,fixedList = G2stIO.GetConstraints(GPXfile)
varyListStart = tuple(varyList) # save the original varyList before dependent vars are removed
try:
groups,parmlist = G2mv.GroupConstraints(constrDict)
G2mv.GenerateConstraints(groups,parmlist,varyList,constrDict,fixedList,parmDict,SeqHist=ihst)
constraintInfo = (groups,parmlist,constrDict,fixedList,ihst)
except:
print ' *** ERROR - your constraints are internally inconsistent ***'
#errmsg, warnmsg = G2mv.CheckConstraints(varyList,constrDict,fixedList)
#print 'Errors',errmsg
#if warnmsg: print 'Warnings',warnmsg
return False,' Constraint error'
#print G2mv.VarRemapShow(varyList)
if not ihst:
# first histogram to refine against
firstVaryList = []
for item in varyList:
items = item.split(':')
if items[1]:
items[1] = ''
item = ':'.join(items)
firstVaryList.append(item)
newVaryList = firstVaryList
else:
newVaryList = []
for item in varyList:
items = item.split(':')
if items[1]:
items[1] = ''
item = ':'.join(items)
newVaryList.append(item)
if newVaryList != firstVaryList and Controls['Copy2Next']:
# variable lists are expected to match between sequential refinements when Copy2Next is on
print '**** ERROR - variable list for this histogram does not match previous'
print ' Copy of variables is not possible'
print '\ncurrent histogram',histogram,'has',len(newVaryList),'variables'
combined = list(set(firstVaryList+newVaryList))
c = [var for var in combined if var not in newVaryList]
p = [var for var in combined if var not in firstVaryList]
line = 'Variables in previous but not in current: '
if c:
for var in c:
if len(line) > 100:
print line
line = ' '
line += var + ', '
else:
line += 'none'
print line
print '\nPrevious refinement has',len(firstVaryList),'variables'
line = 'Variables in current but not in previous: '
if p:
for var in p:
if len(line) > 100:
print line
line = ' '
line += var + ', '
else:
line += 'none'
print line
return False,line
ifPrint = False
print >>printFile,'\n Refinement results for histogram: v'+histogram
print >>printFile,135*'-'
try:
IfOK,Rvals,result,covMatrix,sig = RefineCore(Controls,Histo,Phases,restraintDict,
rigidbodyDict,parmDict,varyList,calcControls,pawleyLookup,ifPrint,printFile,dlg)
print ' wR = %7.2f%%, chi**2 = %12.6g, reduced chi**2 = %6.2f, last delta chi = %.4f'%(
Rvals['Rwp'],Rvals['chisq'],Rvals['GOF']**2,Rvals['DelChi2'])
# add the uncertainties into the esd dictionary (sigDict)
sigDict = dict(zip(varyList,sig))
# the uncertainties for dependent constrained parms into the esd dict
sigDict.update(G2mv.ComputeDepESD(covMatrix,varyList,parmDict))
# a dict with values & esds for dependent (constrained) parameters
depParmDict = {i:(parmDict[i],sigDict[i]) for i in varyListStart
if i not in varyList}
newCellDict = copy.deepcopy(G2stMth.GetNewCellParms(parmDict,varyList))
newAtomDict = copy.deepcopy(G2stMth.ApplyXYZshifts(parmDict,varyList))
histRefData = {
'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
'varyListStart':varyListStart,
'covMatrix':covMatrix,'title':histogram,'newAtomDict':newAtomDict,
'newCellDict':newCellDict,'depParmDict':depParmDict,
'constraintInfo':constraintInfo,
'parmDict':parmDict}
SeqResult[histogram] = histRefData
G2stMth.ApplyRBModels(parmDict,Phases,rigidbodyDict,True)
# G2stIO.SetRigidBodyModels(parmDict,sigDict,rigidbodyDict,printFile)
G2stIO.SetHistogramPhaseData(parmDict,sigDict,Phases,Histo,None,ifPrint,printFile)
G2stIO.SetHistogramData(parmDict,sigDict,Histo,None,ifPrint,printFile)
G2stIO.SetUsedHistogramsAndPhases(GPXfile,Histo,Phases,rigidbodyDict,histRefData,makeBack)
makeBack = False
NewparmDict = {}
# make dict of varied parameters in current histogram, renamed to
# next histogram, for use in next refinement.
if Controls['Copy2Next'] and ihst < len(histNames)-1:
hId = Histo[histogram]['hId'] # current histogram
nexthId = Histograms[histNames[ihst+1]]['hId']
for parm in set(list(varyList)+list(varyListStart)):
items = parm.split(':')
if len(items) < 3: continue
if str(hId) in items[1]:
items[1] = str(nexthId)
newparm = ':'.join(items)
NewparmDict[newparm] = parmDict[parm]
except G2obj.G2Exception,Msg:
printFile.close()
print ' ***** Refinement aborted *****'
return False,Msg.msg
def Refine(GPXfile,dlg):
'Global refinement -- refines to minimize against all histograms'
import pytexture as ptx
ptx.pyqlmninit() #initialize fortran arrays for spherical harmonics
printFile = open(ospath.splitext(GPXfile)[0]+'.lst','w')
G2stIO.ShowBanner(printFile)
varyList = []
parmDict = {}
G2mv.InitVars()
Controls = G2stIO.GetControls(GPXfile)
G2stIO.ShowControls(Controls,printFile)
calcControls = {}
calcControls.update(Controls)
constrDict,fixedList = G2stIO.GetConstraints(GPXfile)
restraintDict = G2stIO.GetRestraints(GPXfile)
Histograms,Phases = G2stIO.GetUsedHistogramsAndPhases(GPXfile)
if not Phases:
print ' *** ERROR - you have no phases to refine! ***'
print ' *** Refine aborted ***'
return False,'No phases'
if not Histograms:
print ' *** ERROR - you have no data to refine with! ***'
print ' *** Refine aborted ***'
return False,'No data'
rigidbodyDict = G2stIO.GetRigidBodies(GPXfile)
rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,pFile=printFile)
Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables,maxSSwave = G2stIO.GetPhaseData(Phases,restraintDict,rbIds,pFile=printFile)
calcControls['atomIndx'] = atomIndx
calcControls['Natoms'] = Natoms
calcControls['FFtables'] = FFtables
calcControls['BLtables'] = BLtables
calcControls['maxSSwave'] = maxSSwave
hapVary,hapDict,controlDict = G2stIO.GetHistogramPhaseData(Phases,Histograms,pFile=printFile)
calcControls.update(controlDict)
histVary,histDict,controlDict = G2stIO.GetHistogramData(Histograms,pFile=printFile)
calcControls.update(controlDict)
varyList = rbVary+phaseVary+hapVary+histVary
parmDict.update(rbDict)
parmDict.update(phaseDict)
parmDict.update(hapDict)
parmDict.update(histDict)
G2stIO.GetFprime(calcControls,Histograms)
# do constraint processing
varyListStart = tuple(varyList) # save the original varyList before dependent vars are removed
try:
groups,parmlist = G2mv.GroupConstraints(constrDict)
G2mv.GenerateConstraints(groups,parmlist,varyList,constrDict,fixedList,parmDict)
#print G2mv.VarRemapShow(varyList)
#print 'DependentVars',G2mv.GetDependentVars()
#print 'IndependentVars',G2mv.GetIndependentVars()
except:
print ' *** ERROR - your constraints are internally inconsistent ***'
#errmsg, warnmsg = G2mv.CheckConstraints(varyList,constrDict,fixedList)
#print 'Errors',errmsg
#if warnmsg: print 'Warnings',warnmsg
return False,' Constraint error'
# print G2mv.VarRemapShow(varyList)
ifPrint = True
print >>printFile,'\n Refinement results:'
print >>printFile,135*'-'
try:
IfOK,Rvals,result,covMatrix,sig = RefineCore(Controls,Histograms,Phases,restraintDict,
rigidbodyDict,parmDict,varyList,calcControls,pawleyLookup,ifPrint,printFile,dlg)
sigDict = dict(zip(varyList,sig))
newCellDict = G2stMth.GetNewCellParms(parmDict,varyList)
newAtomDict = G2stMth.ApplyXYZshifts(parmDict,varyList)
covData = {'variables':result[0],'varyList':varyList,'sig':sig,'Rvals':Rvals,
'varyListStart':varyListStart,
'covMatrix':covMatrix,'title':GPXfile,'newAtomDict':newAtomDict,
'newCellDict':newCellDict,'freshCOV':True}
# add the uncertainties into the esd dictionary (sigDict)
sigDict.update(G2mv.ComputeDepESD(covMatrix,varyList,parmDict))
G2mv.PrintIndependentVars(parmDict,varyList,sigDict,pFile=printFile)
G2stMth.ApplyRBModels(parmDict,Phases,rigidbodyDict,True)
G2stIO.SetRigidBodyModels(parmDict,sigDict,rigidbodyDict,printFile)
G2stIO.SetPhaseData(parmDict,sigDict,Phases,rbIds,covData,restraintDict,printFile)
G2stIO.SetHistogramPhaseData(parmDict,sigDict,Phases,Histograms,calcControls['FFtables'],pFile=printFile)
G2stIO.SetHistogramData(parmDict,sigDict,Histograms,calcControls['FFtables'],pFile=printFile)
G2stIO.SetUsedHistogramsAndPhases(GPXfile,Histograms,Phases,rigidbodyDict,covData)
printFile.close()
print ' Refinement results are in file: '+ospath.splitext(GPXfile)[0]+'.lst'
print ' ***** Refinement successful *****'
except G2obj.G2Exception,Msg:
printFile.close()
return False,Msg.msg
# next histogram, for use in next refinement.
if Controls['Copy2Next'] and ihst < len(histNames)-1:
hId = Histo[histogram]['hId'] # current histogram
nexthId = Histograms[histNames[ihst+1]]['hId']
for parm in set(list(varyList)+list(varyListStart)):
items = parm.split(':')
if len(items) < 3: continue
if str(hId) in items[1]:
items[1] = str(nexthId)
newparm = ':'.join(items)
NewparmDict[newparm] = parmDict[parm]
except G2obj.G2Exception,Msg:
printFile.close()
print ' ***** Refinement aborted *****'
return False,Msg.msg
G2stIO.SetSeqResult(GPXfile,Histograms,SeqResult)
printFile.close()
print ' Sequential refinement results are in file: '+ospath.splitext(GPXfile)[0]+'.lst'
print ' ***** Sequential refinement successful *****'
return True,'Success'
def RetDistAngle(DisAglCtls,DisAglData):
'''Compute and return distances and angles
:param dict DisAglCtls: contains distance/angle radii usually defined using
:func:`GSASIIgrid.DisAglDialog`
:param dict DisAglData: contains phase data:
Items 'OrigAtoms' and 'TargAtoms' contain the atoms to be used
for distance/angle origins and atoms to be used as targets.
Item 'SGData' has the space group information (see :ref:`Space Group object<SGData_table>`)
