source: trunk/GSASIIstrMath.py @ 3881

Last change on this file since 3881 was 3881, checked in by vondreele, 3 years ago

mag. str fctr. (again...)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Author Revision URL Id
File size: 215.3 KB
Line 
1# -*- coding: utf-8 -*-
2'''
3*GSASIIstrMath - structure math routines*
4-----------------------------------------
5'''
6########### SVN repository information ###################
7# $Date: 2019-04-08 20:22:13 +0000 (Mon, 08 Apr 2019) $
8# $Author: vondreele $
9# $Revision: 3881 $
10# $URL: trunk/GSASIIstrMath.py $
11# $Id: GSASIIstrMath.py 3881 2019-04-08 20:22:13Z vondreele $
12########### SVN repository information ###################
13from __future__ import division, print_function
14import time
15import copy
16import numpy as np
17import numpy.ma as ma
18import numpy.linalg as nl
19import scipy.stats as st
20import multiprocessing as mp
21import GSASIIpath
22GSASIIpath.SetVersionNumber("$Revision: 3881 $")
23import GSASIIElem as G2el
24import GSASIIlattice as G2lat
25import GSASIIspc as G2spc
26import GSASIIpwd as G2pwd
27import GSASIImapvars as G2mv
28import GSASIImath as G2mth
29import GSASIIobj as G2obj
30import GSASIImpsubs as G2mp
31#G2mp.InitMP(False)  # This disables multiprocessing
32
33sind = lambda x: np.sin(x*np.pi/180.)
34cosd = lambda x: np.cos(x*np.pi/180.)
35tand = lambda x: np.tan(x*np.pi/180.)
36asind = lambda x: 180.*np.arcsin(x)/np.pi
37acosd = lambda x: 180.*np.arccos(x)/np.pi
38atan2d = lambda y,x: 180.*np.arctan2(y,x)/np.pi
39   
40ateln2 = 8.0*np.log(2.0)
41twopi = 2.0*np.pi
42twopisq = 2.0*np.pi**2
43nxs = np.newaxis
44
45################################################################################
46##### Rigid Body Models
47################################################################################
48       
49def ApplyRBModels(parmDict,Phases,rigidbodyDict,Update=False):
50    ''' Takes RB info from RBModels in Phase and RB data in rigidbodyDict along with
51    current RB values in parmDict & modifies atom contents (xyz & Uij) of parmDict
52    '''
53    atxIds = ['Ax:','Ay:','Az:']
54    atuIds = ['AU11:','AU22:','AU33:','AU12:','AU13:','AU23:']
55    RBIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})  #these are lists of rbIds
56    if not RBIds['Vector'] and not RBIds['Residue']:
57        return
58    VRBIds = RBIds['Vector']
59    RRBIds = RBIds['Residue']
60    if Update:
61        RBData = rigidbodyDict
62    else:
63        RBData = copy.deepcopy(rigidbodyDict)     # don't mess with original!
64    if RBIds['Vector']:                       # first update the vector magnitudes
65        VRBData = RBData['Vector']
66        for i,rbId in enumerate(VRBIds):
67            if VRBData[rbId]['useCount']:
68                for j in range(len(VRBData[rbId]['VectMag'])):
69                    name = '::RBV;'+str(j)+':'+str(i)
70                    VRBData[rbId]['VectMag'][j] = parmDict[name]
71    for phase in Phases:
72        Phase = Phases[phase]
73        General = Phase['General']
74        cx,ct,cs,cia = General['AtomPtrs']
75        cell = General['Cell'][1:7]
76        Amat,Bmat = G2lat.cell2AB(cell)
77        AtLookup = G2mth.FillAtomLookUp(Phase['Atoms'],cia+8)
78        pfx = str(Phase['pId'])+'::'
79        if Update:
80            RBModels = Phase['RBModels']
81        else:
82            RBModels =  copy.deepcopy(Phase['RBModels']) # again don't mess with original!
83        for irb,RBObj in enumerate(RBModels.get('Vector',[])):
84            jrb = VRBIds.index(RBObj['RBId'])
85            rbsx = str(irb)+':'+str(jrb)
86            for i,px in enumerate(['RBVPx:','RBVPy:','RBVPz:']):
87                RBObj['Orig'][0][i] = parmDict[pfx+px+rbsx]
88            for i,po in enumerate(['RBVOa:','RBVOi:','RBVOj:','RBVOk:']):
89                RBObj['Orient'][0][i] = parmDict[pfx+po+rbsx]
90            RBObj['Orient'][0] = G2mth.normQ(RBObj['Orient'][0])
91            TLS = RBObj['ThermalMotion']
92            if 'T' in TLS[0]:
93                for i,pt in enumerate(['RBVT11:','RBVT22:','RBVT33:','RBVT12:','RBVT13:','RBVT23:']):
94                    TLS[1][i] = parmDict[pfx+pt+rbsx]
95            if 'L' in TLS[0]:
96                for i,pt in enumerate(['RBVL11:','RBVL22:','RBVL33:','RBVL12:','RBVL13:','RBVL23:']):
97                    TLS[1][i+6] = parmDict[pfx+pt+rbsx]
98            if 'S' in TLS[0]:
99                for i,pt in enumerate(['RBVS12:','RBVS13:','RBVS21:','RBVS23:','RBVS31:','RBVS32:','RBVSAA:','RBVSBB:']):
100                    TLS[1][i+12] = parmDict[pfx+pt+rbsx]
101            if 'U' in TLS[0]:
102                TLS[1][0] = parmDict[pfx+'RBVU:'+rbsx]
103            XYZ,Cart = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,'Vector')
104            UIJ = G2mth.UpdateRBUIJ(Bmat,Cart,RBObj)
105            for i,x in enumerate(XYZ):
106                atId = RBObj['Ids'][i]
107                for j in [0,1,2]:
108                    parmDict[pfx+atxIds[j]+str(AtLookup[atId])] = x[j]
109                if UIJ[i][0] == 'A':
110                    for j in range(6):
111                        parmDict[pfx+atuIds[j]+str(AtLookup[atId])] = UIJ[i][j+2]
112                elif UIJ[i][0] == 'I':
113                    parmDict[pfx+'AUiso:'+str(AtLookup[atId])] = UIJ[i][1]
114           
115        for irb,RBObj in enumerate(RBModels.get('Residue',[])):
116            jrb = RRBIds.index(RBObj['RBId'])
117            rbsx = str(irb)+':'+str(jrb)
118            for i,px in enumerate(['RBRPx:','RBRPy:','RBRPz:']):
119                RBObj['Orig'][0][i] = parmDict[pfx+px+rbsx]
120            for i,po in enumerate(['RBROa:','RBROi:','RBROj:','RBROk:']):
121                RBObj['Orient'][0][i] = parmDict[pfx+po+rbsx]               
122            RBObj['Orient'][0] = G2mth.normQ(RBObj['Orient'][0])
123            TLS = RBObj['ThermalMotion']
124            if 'T' in TLS[0]:
125                for i,pt in enumerate(['RBRT11:','RBRT22:','RBRT33:','RBRT12:','RBRT13:','RBRT23:']):
126                    RBObj['ThermalMotion'][1][i] = parmDict[pfx+pt+rbsx]
127            if 'L' in TLS[0]:
128                for i,pt in enumerate(['RBRL11:','RBRL22:','RBRL33:','RBRL12:','RBRL13:','RBRL23:']):
129                    RBObj['ThermalMotion'][1][i+6] = parmDict[pfx+pt+rbsx]
130            if 'S' in TLS[0]:
131                for i,pt in enumerate(['RBRS12:','RBRS13:','RBRS21:','RBRS23:','RBRS31:','RBRS32:','RBRSAA:','RBRSBB:']):
132                    RBObj['ThermalMotion'][1][i+12] = parmDict[pfx+pt+rbsx]
133            if 'U' in TLS[0]:
134                RBObj['ThermalMotion'][1][0] = parmDict[pfx+'RBRU:'+rbsx]
135            for itors,tors in enumerate(RBObj['Torsions']):
136                tors[0] = parmDict[pfx+'RBRTr;'+str(itors)+':'+rbsx]
137            XYZ,Cart = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,'Residue')
138            UIJ = G2mth.UpdateRBUIJ(Bmat,Cart,RBObj)
139            for i,x in enumerate(XYZ):
140                atId = RBObj['Ids'][i]
141                for j in [0,1,2]:
142                    parmDict[pfx+atxIds[j]+str(AtLookup[atId])] = x[j]
143                if UIJ[i][0] == 'A':
144                    for j in range(6):
145                        parmDict[pfx+atuIds[j]+str(AtLookup[atId])] = UIJ[i][j+2]
146                elif UIJ[i][0] == 'I':
147                    parmDict[pfx+'AUiso:'+str(AtLookup[atId])] = UIJ[i][1]
148                   
149def ApplyRBModelDervs(dFdvDict,parmDict,rigidbodyDict,Phase):
150    'Needs a doc string'
151    atxIds = ['dAx:','dAy:','dAz:']
152    atuIds = ['AU11:','AU22:','AU33:','AU12:','AU13:','AU23:']
153    OIds = ['Oa:','Oi:','Oj:','Ok:']
154    RBIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})  #these are lists of rbIds
155    if not RBIds['Vector'] and not RBIds['Residue']:
156        return
157    VRBIds = RBIds['Vector']
158    RRBIds = RBIds['Residue']
159    RBData = rigidbodyDict
160    for item in parmDict:
161        if 'RB' in item:
162            dFdvDict[item] = 0.        #NB: this is a vector which is no. refl. long & must be filled!
163    General = Phase['General']
164    cx,ct,cs,cia = General['AtomPtrs']
165    cell = General['Cell'][1:7]
166    Amat,Bmat = G2lat.cell2AB(cell)
167    rpd = np.pi/180.
168    rpd2 = rpd**2
169    g = nl.inv(np.inner(Bmat,Bmat))
170    gvec = np.sqrt(np.array([g[0][0]**2,g[1][1]**2,g[2][2]**2,
171        g[0][0]*g[1][1],g[0][0]*g[2][2],g[1][1]*g[2][2]]))
172    AtLookup = G2mth.FillAtomLookUp(Phase['Atoms'],cia+8)
173    pfx = str(Phase['pId'])+'::'
174    RBModels =  Phase['RBModels']
175    for irb,RBObj in enumerate(RBModels.get('Vector',[])):
176        VModel = RBData['Vector'][RBObj['RBId']]
177        Q = RBObj['Orient'][0]
178        jrb = VRBIds.index(RBObj['RBId'])
179        rbsx = str(irb)+':'+str(jrb)
180        dXdv = []
181        for iv in range(len(VModel['VectMag'])):
182            dCdv = []
183            for vec in VModel['rbVect'][iv]:
184                dCdv.append(G2mth.prodQVQ(Q,vec))
185            dXdv.append(np.inner(Bmat,np.array(dCdv)).T)
186        XYZ,Cart = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,'Vector')
187        for ia,atId in enumerate(RBObj['Ids']):
188            atNum = AtLookup[atId]
189            dx = 0.00001
190            for iv in range(len(VModel['VectMag'])):
191                for ix in [0,1,2]:
192                    dFdvDict['::RBV;'+str(iv)+':'+str(jrb)] += dXdv[iv][ia][ix]*dFdvDict[pfx+atxIds[ix]+str(atNum)]
193            for i,name in enumerate(['RBVPx:','RBVPy:','RBVPz:']):
194                dFdvDict[pfx+name+rbsx] += dFdvDict[pfx+atxIds[i]+str(atNum)]
195            for iv in range(4):
196                Q[iv] -= dx
197                XYZ1 = G2mth.RotateRBXYZ(Bmat,Cart,G2mth.normQ(Q))
198                Q[iv] += 2.*dx
199                XYZ2 = G2mth.RotateRBXYZ(Bmat,Cart,G2mth.normQ(Q))
200                Q[iv] -= dx
201                dXdO = (XYZ2[ia]-XYZ1[ia])/(2.*dx)
202                for ix in [0,1,2]:
203                    dFdvDict[pfx+'RBV'+OIds[iv]+rbsx] += dXdO[ix]*dFdvDict[pfx+atxIds[ix]+str(atNum)]
204            X = G2mth.prodQVQ(Q,Cart[ia])
205            dFdu = np.array([dFdvDict[pfx+Uid+str(AtLookup[atId])] for Uid in atuIds]).T/gvec
206            dFdu = G2lat.U6toUij(dFdu.T)
207            dFdu = np.tensordot(Amat,np.tensordot(Amat,dFdu,([1,0])),([0,1]))           
208            dFdu = G2lat.UijtoU6(dFdu)
209            atNum = AtLookup[atId]
210            if 'T' in RBObj['ThermalMotion'][0]:
211                for i,name in enumerate(['RBVT11:','RBVT22:','RBVT33:','RBVT12:','RBVT13:','RBVT23:']):
212                    dFdvDict[pfx+name+rbsx] += dFdu[i]
213            if 'L' in RBObj['ThermalMotion'][0]:
214                dFdvDict[pfx+'RBVL11:'+rbsx] += rpd2*(dFdu[1]*X[2]**2+dFdu[2]*X[1]**2-dFdu[5]*X[1]*X[2])
215                dFdvDict[pfx+'RBVL22:'+rbsx] += rpd2*(dFdu[0]*X[2]**2+dFdu[2]*X[0]**2-dFdu[4]*X[0]*X[2])
216                dFdvDict[pfx+'RBVL33:'+rbsx] += rpd2*(dFdu[0]*X[1]**2+dFdu[1]*X[0]**2-dFdu[3]*X[0]*X[1])
217                dFdvDict[pfx+'RBVL12:'+rbsx] += rpd2*(-dFdu[3]*X[2]**2-2.*dFdu[2]*X[0]*X[1]+
218                    dFdu[4]*X[1]*X[2]+dFdu[5]*X[0]*X[2])
219                dFdvDict[pfx+'RBVL13:'+rbsx] += rpd2*(-dFdu[4]*X[1]**2-2.*dFdu[1]*X[0]*X[2]+
220                    dFdu[3]*X[1]*X[2]+dFdu[5]*X[0]*X[1])
221                dFdvDict[pfx+'RBVL23:'+rbsx] += rpd2*(-dFdu[5]*X[0]**2-2.*dFdu[0]*X[1]*X[2]+
222                    dFdu[3]*X[0]*X[2]+dFdu[4]*X[0]*X[1])
223            if 'S' in RBObj['ThermalMotion'][0]:
224                dFdvDict[pfx+'RBVS12:'+rbsx] += rpd*(dFdu[5]*X[1]-2.*dFdu[1]*X[2])
225                dFdvDict[pfx+'RBVS13:'+rbsx] += rpd*(-dFdu[5]*X[2]+2.*dFdu[2]*X[1])
226                dFdvDict[pfx+'RBVS21:'+rbsx] += rpd*(-dFdu[4]*X[0]+2.*dFdu[0]*X[2])
227                dFdvDict[pfx+'RBVS23:'+rbsx] += rpd*(dFdu[4]*X[2]-2.*dFdu[2]*X[0])
228                dFdvDict[pfx+'RBVS31:'+rbsx] += rpd*(dFdu[3]*X[0]-2.*dFdu[0]*X[1])
229                dFdvDict[pfx+'RBVS32:'+rbsx] += rpd*(-dFdu[3]*X[1]+2.*dFdu[1]*X[0])
230                dFdvDict[pfx+'RBVSAA:'+rbsx] += rpd*(dFdu[4]*X[1]-dFdu[3]*X[2])
231                dFdvDict[pfx+'RBVSBB:'+rbsx] += rpd*(dFdu[5]*X[0]-dFdu[3]*X[2])
232            if 'U' in RBObj['ThermalMotion'][0]:
233                dFdvDict[pfx+'RBVU:'+rbsx] += dFdvDict[pfx+'AUiso:'+str(AtLookup[atId])]
234
235
236    for irb,RBObj in enumerate(RBModels.get('Residue',[])):
237        Q = RBObj['Orient'][0]
238        jrb = RRBIds.index(RBObj['RBId'])
239        torData = RBData['Residue'][RBObj['RBId']]['rbSeq']
240        rbsx = str(irb)+':'+str(jrb)
241        XYZ,Cart = G2mth.UpdateRBXYZ(Bmat,RBObj,RBData,'Residue')
242        for itors,tors in enumerate(RBObj['Torsions']):     #derivative error?
243            tname = pfx+'RBRTr;'+str(itors)+':'+rbsx           
244            orId,pvId = torData[itors][:2]
245            pivotVec = Cart[orId]-Cart[pvId]
246            QA = G2mth.AVdeg2Q(-0.001,pivotVec)
247            QB = G2mth.AVdeg2Q(0.001,pivotVec)
248            for ir in torData[itors][3]:
249                atNum = AtLookup[RBObj['Ids'][ir]]
250                rVec = Cart[ir]-Cart[pvId]
251                dR = G2mth.prodQVQ(QB,rVec)-G2mth.prodQVQ(QA,rVec)
252                dRdT = np.inner(Bmat,G2mth.prodQVQ(Q,dR))/.002
253                for ix in [0,1,2]:
254                    dFdvDict[tname] += dRdT[ix]*dFdvDict[pfx+atxIds[ix]+str(atNum)]
255        for ia,atId in enumerate(RBObj['Ids']):
256            atNum = AtLookup[atId]
257            dx = 0.00001
258            for i,name in enumerate(['RBRPx:','RBRPy:','RBRPz:']):
259                dFdvDict[pfx+name+rbsx] += dFdvDict[pfx+atxIds[i]+str(atNum)]
260            for iv in range(4):
261                Q[iv] -= dx
262                XYZ1 = G2mth.RotateRBXYZ(Bmat,Cart,G2mth.normQ(Q))
263                Q[iv] += 2.*dx
264                XYZ2 = G2mth.RotateRBXYZ(Bmat,Cart,G2mth.normQ(Q))
265                Q[iv] -= dx
266                dXdO = (XYZ2[ia]-XYZ1[ia])/(2.*dx)
267                for ix in [0,1,2]:
268                    dFdvDict[pfx+'RBR'+OIds[iv]+rbsx] += dXdO[ix]*dFdvDict[pfx+atxIds[ix]+str(atNum)]
269            X = G2mth.prodQVQ(Q,Cart[ia])
270            dFdu = np.array([dFdvDict[pfx+Uid+str(AtLookup[atId])] for Uid in atuIds]).T/gvec
271            dFdu = G2lat.U6toUij(dFdu.T)
272            dFdu = np.tensordot(Amat.T,np.tensordot(Amat,dFdu,([1,0])),([0,1]))
273            dFdu = G2lat.UijtoU6(dFdu)
274            atNum = AtLookup[atId]
275            if 'T' in RBObj['ThermalMotion'][0]:
276                for i,name in enumerate(['RBRT11:','RBRT22:','RBRT33:','RBRT12:','RBRT13:','RBRT23:']):
277                    dFdvDict[pfx+name+rbsx] += dFdu[i]
278            if 'L' in RBObj['ThermalMotion'][0]:
279                dFdvDict[pfx+'RBRL11:'+rbsx] += rpd2*(dFdu[1]*X[2]**2+dFdu[2]*X[1]**2-dFdu[5]*X[1]*X[2])
280                dFdvDict[pfx+'RBRL22:'+rbsx] += rpd2*(dFdu[0]*X[2]**2+dFdu[2]*X[0]**2-dFdu[4]*X[0]*X[2])
281                dFdvDict[pfx+'RBRL33:'+rbsx] += rpd2*(dFdu[0]*X[1]**2+dFdu[1]*X[0]**2-dFdu[3]*X[0]*X[1])
282                dFdvDict[pfx+'RBRL12:'+rbsx] += rpd2*(-dFdu[3]*X[2]**2-2.*dFdu[2]*X[0]*X[1]+
283                    dFdu[4]*X[1]*X[2]+dFdu[5]*X[0]*X[2])
284                dFdvDict[pfx+'RBRL13:'+rbsx] += rpd2*(dFdu[4]*X[1]**2-2.*dFdu[1]*X[0]*X[2]+
285                    dFdu[3]*X[1]*X[2]+dFdu[5]*X[0]*X[1])
286                dFdvDict[pfx+'RBRL23:'+rbsx] += rpd2*(dFdu[5]*X[0]**2-2.*dFdu[0]*X[1]*X[2]+
287                    dFdu[3]*X[0]*X[2]+dFdu[4]*X[0]*X[1])
288            if 'S' in RBObj['ThermalMotion'][0]:
289                dFdvDict[pfx+'RBRS12:'+rbsx] += rpd*(dFdu[5]*X[1]-2.*dFdu[1]*X[2])
290                dFdvDict[pfx+'RBRS13:'+rbsx] += rpd*(-dFdu[5]*X[2]+2.*dFdu[2]*X[1])
291                dFdvDict[pfx+'RBRS21:'+rbsx] += rpd*(-dFdu[4]*X[0]+2.*dFdu[0]*X[2])
292                dFdvDict[pfx+'RBRS23:'+rbsx] += rpd*(dFdu[4]*X[2]-2.*dFdu[2]*X[0])
293                dFdvDict[pfx+'RBRS31:'+rbsx] += rpd*(dFdu[3]*X[0]-2.*dFdu[0]*X[1])
294                dFdvDict[pfx+'RBRS32:'+rbsx] += rpd*(-dFdu[3]*X[1]+2.*dFdu[1]*X[0])
295                dFdvDict[pfx+'RBRSAA:'+rbsx] += rpd*(dFdu[4]*X[1]-dFdu[3]*X[2])
296                dFdvDict[pfx+'RBRSBB:'+rbsx] += rpd*(dFdu[5]*X[0]-dFdu[3]*X[2])
297            if 'U' in RBObj['ThermalMotion'][0]:
298                dFdvDict[pfx+'RBRU:'+rbsx] += dFdvDict[pfx+'AUiso:'+str(AtLookup[atId])]
299   
300################################################################################
301##### Penalty & restraint functions
302################################################################################
303
304def penaltyFxn(HistoPhases,calcControls,parmDict,varyList):
305    'Compute user-supplied and built-in restraint functions'
306    Histograms,Phases,restraintDict,rigidbodyDict = HistoPhases
307    pNames = []
308    pVals = []
309    pWt = []
310    negWt = {}
311    pWsum = {}
312    pWnum = {}
313    for phase in Phases:
314        pId = Phases[phase]['pId']
315        negWt[pId] = Phases[phase]['General']['Pawley neg wt']
316        General = Phases[phase]['General']
317        cx,ct,cs,cia = General['AtomPtrs']
318        textureData = General['SH Texture']
319        SGData = General['SGData']
320        Atoms = Phases[phase]['Atoms']
321        AtLookup = G2mth.FillAtomLookUp(Phases[phase]['Atoms'],cia+8)
322        cell = General['Cell'][1:7]
323        Amat,Bmat = G2lat.cell2AB(cell)
324        if phase not in restraintDict:
325            continue
326        phaseRest = restraintDict[phase]
327        names = [['Bond','Bonds'],['Angle','Angles'],['Plane','Planes'],
328            ['Chiral','Volumes'],['Torsion','Torsions'],['Rama','Ramas'],
329            ['ChemComp','Sites'],['Texture','HKLs'],['General','General'],]
330        for name,rest in names:
331            pWsum[name] = 0.
332            pWnum[name] = 0
333            if name not in phaseRest:
334                continue
335            itemRest = phaseRest[name]
336            if itemRest[rest] and itemRest['Use']:
337                wt = itemRest.get('wtFactor',1.)
338                if name in ['Bond','Angle','Plane','Chiral']:
339                    for i,[indx,ops,obs,esd] in enumerate(itemRest[rest]):
340                        pNames.append(str(pId)+':'+name+':'+str(i))
341                        XYZ = np.array(G2mth.GetAtomCoordsByID(pId,parmDict,AtLookup,indx))
342                        XYZ = G2mth.getSyXYZ(XYZ,ops,SGData)
343                        if name == 'Bond':
344                            calc = G2mth.getRestDist(XYZ,Amat)
345                        elif name == 'Angle':
346                            calc = G2mth.getRestAngle(XYZ,Amat)
347                        elif name == 'Plane':
348                            calc = G2mth.getRestPlane(XYZ,Amat)
349                        elif name == 'Chiral':
350                            calc = G2mth.getRestChiral(XYZ,Amat)
351                        pVals.append(obs-calc)
352                        pWt.append(wt/esd**2)
353                        pWsum[name] += wt*((obs-calc)/esd)**2
354                        pWnum[name] += 1
355                elif name in ['Torsion','Rama']:
356                    coeffDict = itemRest['Coeff']
357                    for i,[indx,ops,cofName,esd] in enumerate(itemRest[rest]):
358                        pNames.append(str(pId)+':'+name+':'+str(i))
359                        XYZ = np.array(G2mth.GetAtomCoordsByID(pId,parmDict,AtLookup,indx))
360                        XYZ = G2mth.getSyXYZ(XYZ,ops,SGData)
361                        if name == 'Torsion':
362                            tor = G2mth.getRestTorsion(XYZ,Amat)
363                            restr,calc = G2mth.calcTorsionEnergy(tor,coeffDict[cofName])
364                        else:
365                            phi,psi = G2mth.getRestRama(XYZ,Amat)
366                            restr,calc = G2mth.calcRamaEnergy(phi,psi,coeffDict[cofName])                               
367                        pVals.append(restr)
368                        pWt.append(wt/esd**2)
369                        pWsum[name] += wt*(restr/esd)**2
370                        pWnum[name] += 1
371                elif name == 'ChemComp':
372                    for i,[indx,factors,obs,esd] in enumerate(itemRest[rest]):
373                        pNames.append(str(pId)+':'+name+':'+str(i))
374                        mul = np.array(G2mth.GetAtomItemsById(Atoms,AtLookup,indx,cs+1))
375                        frac = np.array(G2mth.GetAtomFracByID(pId,parmDict,AtLookup,indx))
376                        calc = np.sum(mul*frac*factors)
377                        pVals.append(obs-calc)
378                        pWt.append(wt/esd**2)                   
379                        pWsum[name] += wt*((obs-calc)/esd)**2
380                        pWnum[name] += 1
381                elif name == 'Texture':
382                    SHkeys = list(textureData['SH Coeff'][1].keys())
383                    SHCoef = G2mth.GetSHCoeff(pId,parmDict,SHkeys)
384                    shModels = ['cylindrical','none','shear - 2/m','rolling - mmm']
385                    SamSym = dict(zip(shModels,['0','-1','2/m','mmm']))
386                    for i,[hkl,grid,esd1,ifesd2,esd2] in enumerate(itemRest[rest]):
387                        PH = np.array(hkl)
388                        phi,beta = G2lat.CrsAng(np.array(hkl),cell,SGData)
389                        ODFln = G2lat.Flnh(False,SHCoef,phi,beta,SGData)
390                        R,P,Z = G2mth.getRestPolefig(ODFln,SamSym[textureData['Model']],grid)
391                        Z1 = ma.masked_greater(Z,0.0)           #is this + or -?
392                        IndZ1 = np.array(ma.nonzero(Z1))
393                        for ind in IndZ1.T:
394                            pNames.append('%d:%s:%d:%.2f:%.2f'%(pId,name,i,R[ind[0],ind[1]],P[ind[0],ind[1]]))
395                            pVals.append(Z1[ind[0]][ind[1]])
396                            pWt.append(wt/esd1**2)
397                            pWsum[name] += wt*(-Z1[ind[0]][ind[1]]/esd1)**2
398                            pWnum[name] += 1
399                        if ifesd2:
400                            Z2 = 1.-Z
401                            for ind in np.ndindex(grid,grid):
402                                pNames.append('%d:%s:%d:%.2f:%.2f'%(pId,name+'-unit',i,R[ind[0],ind[1]],P[ind[0],ind[1]]))
403                                pVals.append(Z2[ind[0]][ind[1]])
404                                pWt.append(wt/esd2**2)
405                                pWsum[name] += wt*(Z2/esd2)**2
406                                pWnum[name] += 1
407                elif name == 'General':
408                    for i,(eq,obs,esd) in enumerate(itemRest[rest]):
409                        pNames.append(str(pId)+':'+name+':'+str(i))
410                        calcobj = G2obj.ExpressionCalcObj(eq)
411                        calcobj.SetupCalc(parmDict)
412                        calc = calcobj.EvalExpression()
413                        pVals.append(obs-calc)
414                        pWt.append(wt/esd**2)                   
415                        pWsum[name] += wt*((obs-calc)/esd)**2
416                        pWnum[name] += 1
417       
418    for phase in Phases:
419        name = 'SH-Pref.Ori.'
420        pId = Phases[phase]['pId']
421        General = Phases[phase]['General']
422        SGData = General['SGData']
423        cell = General['Cell'][1:7]
424        pWsum[name] = 0.0
425        pWnum[name] = 0
426        for hist in Phases[phase]['Histograms']:
427            if not Phases[phase]['Histograms'][hist]['Use']:
428                continue
429            if hist in Histograms and 'PWDR' in hist:
430                hId = Histograms[hist]['hId']
431                phfx = '%d:%d:'%(pId,hId)
432                if calcControls[phfx+'poType'] == 'SH':
433                    toler = calcControls[phfx+'SHtoler']
434                    wt = 1./toler**2
435                    HKLs = np.array(calcControls[phfx+'SHhkl'])
436                    SHnames = calcControls[phfx+'SHnames']
437                    SHcof = dict(zip(SHnames,[parmDict[phfx+cof] for cof in SHnames]))
438                    for i,PH in enumerate(HKLs):
439                        phi,beta = G2lat.CrsAng(PH,cell,SGData)
440                        SH3Coef = {}
441                        for item in SHcof:
442                            L,N = eval(item.strip('C'))
443                            SH3Coef['C%d,0,%d'%(L,N)] = SHcof[item]                       
444                        ODFln = G2lat.Flnh(False,SH3Coef,phi,beta,SGData)
445                        X = np.linspace(0,90.0,26)
446                        Y = ma.masked_greater(G2lat.polfcal(ODFln,'0',X,0.0),0.0)       #+ or -?
447                        IndY = ma.nonzero(Y)
448                        for ind in IndY[0]:
449                            pNames.append('%d:%d:%s:%d:%.2f'%(pId,hId,name,i,X[ind]))
450                            pVals.append(Y[ind])
451                            pWt.append(wt)
452                            pWsum[name] += wt*(Y[ind])**2
453                            pWnum[name] += 1
454    pWsum['PWLref'] = 0.
455    pWnum['PWLref'] = 0
456    for item in varyList:
457        if 'PWLref' in item and parmDict[item] < 0.:
458            pId = int(item.split(':')[0])
459            if negWt[pId]:
460                pNames.append(item)
461                pVals.append(parmDict[item])
462                pWt.append(negWt[pId])
463                pWsum['PWLref'] += negWt[pId]*(parmDict[item])**2
464                pWnum['PWLref'] += 1
465    pVals = np.array(pVals)
466    pWt = np.array(pWt)         #should this be np.sqrt?
467    return pNames,pVals,pWt,pWsum,pWnum
468   
469def penaltyDeriv(pNames,pVal,HistoPhases,calcControls,parmDict,varyList):
470    '''Compute derivatives on user-supplied and built-in restraint
471    (penalty) functions
472
473    where pNames is list of restraint labels
474
475    returns pDerv with partial derivatives by variable# in varList and
476       restraint# in pNames (pDerv[variable#][restraint#])
477    '''
478    Histograms,Phases,restraintDict,rigidbodyDict = HistoPhases
479    pDerv = np.zeros((len(varyList),len(pVal)))
480    for pName in pNames: # loop over restraints
481        if 'General' == pName.split(':')[1]:
482            # initialize for General restraint(s) here
483            GeneralInit = True
484            parmDict0 = parmDict.copy()
485            # setup steps for each parameter
486            stepDict = {}
487            for parm in varyList:
488                stepDict[parm] = G2obj.getVarStep(parm,parmDict)
489            break
490    for phase in Phases:
491#        if phase not in restraintDict:
492#            continue
493        pId = Phases[phase]['pId']
494        General = Phases[phase]['General']
495        cx,ct,cs,cia = General['AtomPtrs']
496        SGData = General['SGData']
497        Atoms = Phases[phase]['Atoms']
498        AtLookup = G2mth.FillAtomLookUp(Phases[phase]['Atoms'],cia+8)
499        cell = General['Cell'][1:7]
500        Amat,Bmat = G2lat.cell2AB(cell)
501        textureData = General['SH Texture']
502
503        SHkeys = list(textureData['SH Coeff'][1].keys())
504        SHCoef = G2mth.GetSHCoeff(pId,parmDict,SHkeys)
505        shModels = ['cylindrical','none','shear - 2/m','rolling - mmm']
506        SamSym = dict(zip(shModels,['0','-1','2/m','mmm']))
507        sam = SamSym[textureData['Model']]
508        phaseRest = restraintDict.get(phase,{})
509        names = {'Bond':'Bonds','Angle':'Angles','Plane':'Planes',
510            'Chiral':'Volumes','Torsion':'Torsions','Rama':'Ramas',
511            'ChemComp':'Sites','Texture':'HKLs'}
512        lasthkl = np.array([0,0,0])
513        for ip,pName in enumerate(pNames): # loop over restraints
514            pnames = pName.split(':')
515            if pId == int(pnames[0]):
516                name = pnames[1]
517                if 'PWL' in pName:
518                    pDerv[varyList.index(pName)][ip] += 1.
519                    continue
520                elif 'SH-' in pName:
521                    continue
522                Id = int(pnames[2]) 
523                itemRest = phaseRest[name]
524                if name in ['Bond','Angle','Plane','Chiral']:
525                    indx,ops,obs,esd = itemRest[names[name]][Id]
526                    dNames = []
527                    for ind in indx:
528                        dNames += [str(pId)+'::dA'+Xname+':'+str(AtLookup[ind]) for Xname in ['x','y','z']]
529                    XYZ = np.array(G2mth.GetAtomCoordsByID(pId,parmDict,AtLookup,indx))
530                    if name == 'Bond':
531                        deriv = G2mth.getRestDeriv(G2mth.getRestDist,XYZ,Amat,ops,SGData)
532                    elif name == 'Angle':
533                        deriv = G2mth.getRestDeriv(G2mth.getRestAngle,XYZ,Amat,ops,SGData)
534                    elif name == 'Plane':
535                        deriv = G2mth.getRestDeriv(G2mth.getRestPlane,XYZ,Amat,ops,SGData)
536                    elif name == 'Chiral':
537                        deriv = G2mth.getRestDeriv(G2mth.getRestChiral,XYZ,Amat,ops,SGData)
538                elif name in ['Torsion','Rama']:
539                    coffDict = itemRest['Coeff']
540                    indx,ops,cofName,esd = itemRest[names[name]][Id]
541                    dNames = []
542                    for ind in indx:
543                        dNames += [str(pId)+'::dA'+Xname+':'+str(AtLookup[ind]) for Xname in ['x','y','z']]
544                    XYZ = np.array(G2mth.GetAtomCoordsByID(pId,parmDict,AtLookup,indx))
545                    if name == 'Torsion':
546                        deriv = G2mth.getTorsionDeriv(XYZ,Amat,coffDict[cofName])
547                    else:
548                        deriv = G2mth.getRamaDeriv(XYZ,Amat,coffDict[cofName])
549                elif name == 'ChemComp':
550                    indx,factors,obs,esd = itemRest[names[name]][Id]
551                    dNames = []
552                    for ind in indx:
553                        dNames += [str(pId)+'::Afrac:'+str(AtLookup[ind])]
554                        mul = np.array(G2mth.GetAtomItemsById(Atoms,AtLookup,indx,cs+1))
555                        deriv = mul*factors
556                elif 'Texture' in name:
557                    deriv = []
558                    dNames = []
559                    hkl,grid,esd1,ifesd2,esd2 = itemRest[names[name]][Id]
560                    hkl = np.array(hkl)
561                    if np.any(lasthkl-hkl):
562                        phi,beta = G2lat.CrsAng(np.array(hkl),cell,SGData)
563                        ODFln = G2lat.Flnh(False,SHCoef,phi,beta,SGData)
564                        lasthkl = copy.copy(hkl)                       
565                    if 'unit' in name:
566                        pass
567                    else:
568                        gam = float(pnames[3])
569                        psi = float(pnames[4])
570                        for SHname in ODFln:
571                            l,m,n = eval(SHname[1:])
572                            Ksl = G2lat.GetKsl(l,m,sam,psi,gam)[0]
573                            dNames += [str(pId)+'::'+SHname]
574                            deriv.append(-ODFln[SHname][0]*Ksl/SHCoef[SHname])
575                elif name == 'General':
576                    deriv = []
577                    dNames = []
578                    eq,obs,esd = itemRest[name][Id]
579                    calcobj = G2obj.ExpressionCalcObj(eq)
580                    parmlist = list(eq.assgnVars.values()) # parameters used in this expression
581                    for parm in parmlist: # expand list if any parms are determined by constraints
582                        if parm in G2mv.dependentVars:
583                            parmlist += G2mv.independentVars
584                            break
585                    for ind,var in enumerate(varyList):
586                        drv = 0
587                        if var in parmlist:
588                            step = stepDict.get(var,1e-5)
589                            calc = []
590                            # apply step to parameter
591                            oneparm = True
592                            for s in -step,2*step:
593                                parmDict[var] += s
594                                # extend shift if needed to other parameters
595                                if var in G2mv.independentVars:
596                                    G2mv.Dict2Map(parmDict,[])
597                                    oneparm = False
598                                elif var in G2mv.dependentVars:
599                                    G2mv.Map2Dict(parmDict,[])
600                                    oneparm = False
601                                if 'RB' in var:
602                                    ApplyRBModels(parmDict,Phases,rigidbodyDict)
603# test
604                                    oneparm = False
605                                calcobj.SetupCalc(parmDict)
606                                calc.append(calcobj.EvalExpression())
607                            drv = (calc[1]-calc[0])*.5/step
608                            # restore the dict
609                            if oneparm:
610                                parmDict[var] = parmDict0[var]
611                            else:
612                                parmDict = parmDict0.copy()
613                        else:
614                            drv = 0
615                        pDerv[ind][ip] = drv
616                # Add derivatives into matrix, if needed
617                for dName,drv in zip(dNames,deriv):
618                    try:
619                        ind = varyList.index(dName)
620                        pDerv[ind][ip] += drv
621                    except ValueError:
622                        pass
623       
624        lasthkl = np.array([0,0,0])
625        for ip,pName in enumerate(pNames):
626            deriv = []
627            dNames = []
628            pnames = pName.split(':')
629            if 'SH-' in pName and pId == int(pnames[0]):
630                hId = int(pnames[1])
631                phfx = '%d:%d:'%(pId,hId)
632                psi = float(pnames[4])
633                HKLs = calcControls[phfx+'SHhkl']
634                SHnames = calcControls[phfx+'SHnames']
635                SHcof = dict(zip(SHnames,[parmDict[phfx+cof] for cof in SHnames]))
636                hkl = np.array(HKLs[int(pnames[3])])     
637                if np.any(lasthkl-hkl):
638                    phi,beta = G2lat.CrsAng(np.array(hkl),cell,SGData)
639                    SH3Coef = {}
640                    for item in SHcof:
641                        L,N = eval(item.strip('C'))
642                        SH3Coef['C%d,0,%d'%(L,N)] = SHcof[item]                       
643                    ODFln = G2lat.Flnh(False,SH3Coef,phi,beta,SGData)
644                    lasthkl = copy.copy(hkl)                       
645                for SHname in SHnames:
646                    l,n = eval(SHname[1:])
647                    SH3name = 'C%d,0,%d'%(l,n)
648                    Ksl = G2lat.GetKsl(l,0,'0',psi,0.0)[0]
649                    dNames += [phfx+SHname]
650                    deriv.append(ODFln[SH3name][0]*Ksl/SHcof[SHname])
651            for dName,drv in zip(dNames,deriv):
652                try:
653                    ind = varyList.index(dName)
654                    pDerv[ind][ip] += drv
655                except ValueError:
656                    pass
657    return pDerv
658
659################################################################################
660##### Function & derivative calculations
661################################################################################       
662                   
663def GetAtomFXU(pfx,calcControls,parmDict):
664    'Needs a doc string'
665    Natoms = calcControls['Natoms'][pfx]
666    Tdata = Natoms*[' ',]
667    Mdata = np.zeros(Natoms)
668    IAdata = Natoms*[' ',]
669    Fdata = np.zeros(Natoms)
670    Xdata = np.zeros((3,Natoms))
671    dXdata = np.zeros((3,Natoms))
672    Uisodata = np.zeros(Natoms)
673    Uijdata = np.zeros((6,Natoms))
674    Gdata = np.zeros((3,Natoms))
675    keys = {'Atype:':Tdata,'Amul:':Mdata,'Afrac:':Fdata,'AI/A:':IAdata,
676        'dAx:':dXdata[0],'dAy:':dXdata[1],'dAz:':dXdata[2],
677        'Ax:':Xdata[0],'Ay:':Xdata[1],'Az:':Xdata[2],'AUiso:':Uisodata,
678        'AU11:':Uijdata[0],'AU22:':Uijdata[1],'AU33:':Uijdata[2],
679        'AU12:':Uijdata[3],'AU13:':Uijdata[4],'AU23:':Uijdata[5],
680        'AMx:':Gdata[0],'AMy:':Gdata[1],'AMz:':Gdata[2],}
681    for iatm in range(Natoms):
682        for key in keys:
683            parm = pfx+key+str(iatm)
684            if parm in parmDict:
685                keys[key][iatm] = parmDict[parm]
686    Fdata = np.where(Fdata,Fdata,1.e-8)         #avoid divide by zero in derivative calc.
687    Gdata = np.where(Gdata,Gdata,1.e-8)         #avoid divide by zero in derivative calc.
688   
689    return Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata
690   
691def GetAtomSSFXU(pfx,calcControls,parmDict):
692    'Needs a doc string'
693    Natoms = calcControls['Natoms'][pfx]
694    maxSSwave = calcControls['maxSSwave'][pfx]
695    Nwave = {'F':maxSSwave['Sfrac'],'X':maxSSwave['Spos'],'Y':maxSSwave['Spos'],'Z':maxSSwave['Spos'],
696        'U':maxSSwave['Sadp'],'M':maxSSwave['Smag'],'T':maxSSwave['Spos']}
697    XSSdata = np.zeros((6,maxSSwave['Spos'],Natoms))
698    FSSdata = np.zeros((2,maxSSwave['Sfrac'],Natoms))
699    USSdata = np.zeros((12,maxSSwave['Sadp'],Natoms))
700    MSSdata = np.zeros((6,maxSSwave['Smag'],Natoms))
701    waveTypes = []
702    keys = {'Fsin:':FSSdata[0],'Fcos:':FSSdata[1],'Fzero:':FSSdata[0],'Fwid:':FSSdata[1],
703        'Tmin:':XSSdata[0],'Tmax:':XSSdata[1],'Xmax:':XSSdata[2],'Ymax:':XSSdata[3],'Zmax:':XSSdata[4],
704        'Xsin:':XSSdata[0],'Ysin:':XSSdata[1],'Zsin:':XSSdata[2],'Xcos:':XSSdata[3],'Ycos:':XSSdata[4],'Zcos:':XSSdata[5],
705        'U11sin:':USSdata[0],'U22sin:':USSdata[1],'U33sin:':USSdata[2],'U12sin:':USSdata[3],'U13sin:':USSdata[4],'U23sin:':USSdata[5],
706        'U11cos:':USSdata[6],'U22cos:':USSdata[7],'U33cos:':USSdata[8],'U12cos:':USSdata[9],'U13cos:':USSdata[10],'U23cos:':USSdata[11],
707        'MXsin:':MSSdata[0],'MYsin:':MSSdata[1],'MZsin:':MSSdata[2],'MXcos:':MSSdata[3],'MYcos:':MSSdata[4],'MZcos:':MSSdata[5]}
708    for iatm in range(Natoms):
709        wavetype = [parmDict.get(pfx+kind+'waveType:'+str(iatm),'') for kind in ['F','P','A','M']]
710        waveTypes.append(wavetype)
711        for key in keys:
712            for m in range(Nwave[key[0]]):
713                parm = pfx+key+str(iatm)+':%d'%(m)
714                if parm in parmDict:
715                    keys[key][m][iatm] = parmDict[parm]
716    return waveTypes,FSSdata,XSSdata,USSdata,MSSdata
717   
718def StructureFactor2(refDict,G,hfx,pfx,SGData,calcControls,parmDict):
719    ''' Compute structure factors for all h,k,l for phase
720    puts the result, F^2, in each ref[8] in refList
721    operates on blocks of 100 reflections for speed
722    input:
723   
724    :param dict refDict: where
725        'RefList' list where each ref = h,k,l,it,d,...
726        'FF' dict of form factors - filed in below
727    :param np.array G:      reciprocal metric tensor
728    :param str pfx:    phase id string
729    :param dict SGData: space group info. dictionary output from SpcGroup
730    :param dict calcControls:
731    :param dict ParmDict:
732
733    '''       
734    phfx = pfx.split(':')[0]+hfx
735    ast = np.sqrt(np.diag(G))
736    Mast = twopisq*np.multiply.outer(ast,ast)
737    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
738    SGT = np.array([ops[1] for ops in SGData['SGOps']])
739    FFtables = calcControls['FFtables']
740    BLtables = calcControls['BLtables']
741    Amat,Bmat = G2lat.Gmat2AB(G)
742    Flack = 1.0
743    if not SGData['SGInv'] and 'S' in calcControls[hfx+'histType'] and phfx+'Flack' in parmDict:
744        Flack = 1.-2.*parmDict[phfx+'Flack']
745    TwinLaw = np.array([[[1,0,0],[0,1,0],[0,0,1]],])
746    TwDict = refDict.get('TwDict',{})           
747    if 'S' in calcControls[hfx+'histType']:
748        NTL = calcControls[phfx+'NTL']
749        NM = calcControls[phfx+'TwinNMN']+1
750        TwinLaw = calcControls[phfx+'TwinLaw']
751        TwinFr = np.array([parmDict[phfx+'TwinFr:'+str(i)] for i in range(len(TwinLaw))])
752        TwinInv = list(np.where(calcControls[phfx+'TwinInv'],-1,1))
753    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
754        GetAtomFXU(pfx,calcControls,parmDict)
755    if not Xdata.size:          #no atoms in phase!
756        return
757    if 'NC' in calcControls[hfx+'histType']:
758        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
759    elif 'X' in calcControls[hfx+'histType']:
760        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
761        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
762    Uij = np.array(G2lat.U6toUij(Uijdata))
763    bij = Mast*Uij.T
764    blkSize = 100       #no. of reflections in a block - size seems optimal
765    nRef = refDict['RefList'].shape[0]
766    SQ = 1./(2.*refDict['RefList'].T[4])**2
767    if 'N' in calcControls[hfx+'histType']:
768        dat = G2el.getBLvalues(BLtables)
769        refDict['FF']['El'] = list(dat.keys())
770        refDict['FF']['FF'] = np.ones((nRef,len(dat)))*list(dat.values())
771    else:       #'X'
772        dat = G2el.getFFvalues(FFtables,0.)
773        refDict['FF']['El'] = list(dat.keys())
774        refDict['FF']['FF'] = np.zeros((nRef,len(dat)))
775        for iel,El in enumerate(refDict['FF']['El']):
776            refDict['FF']['FF'].T[iel] = G2el.ScatFac(FFtables[El],SQ)
777#reflection processing begins here - big arrays!
778    iBeg = 0
779    while iBeg < nRef:
780        iFin = min(iBeg+blkSize,nRef)
781        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
782        H = refl.T[:3]                          #array(blkSize,3)
783        H = np.squeeze(np.inner(H.T,TwinLaw))   #maybe array(blkSize,nTwins,3) or (blkSize,3)
784        TwMask = np.any(H,axis=-1)
785        if TwinLaw.shape[0] > 1 and TwDict: #need np.inner(TwinLaw[?],TwDict[iref][i])*TwinInv[i]
786            for ir in range(blkSize):
787                iref = ir+iBeg
788                if iref in TwDict:
789                    for i in TwDict[iref]:
790                        for n in range(NTL):
791                            H[ir][i+n*NM] = np.inner(TwinLaw[n*NM],np.array(TwDict[iref][i])*TwinInv[i+n*NM])
792            TwMask = np.any(H,axis=-1)
793        SQ = 1./(2.*refl.T[4])**2               #array(blkSize)
794        SQfactor = 4.0*SQ*twopisq               #ditto prev.
795        if 'T' in calcControls[hfx+'histType']:
796            if 'P' in calcControls[hfx+'histType']:
797                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[14])
798            else:
799                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[12])
800            FP = np.repeat(FP.T,len(SGT)*len(TwinLaw),axis=0)
801            FPP = np.repeat(FPP.T,len(SGT)*len(TwinLaw),axis=0)
802        Uniq = np.inner(H,SGMT)
803        Phi = np.inner(H,SGT)
804        phase = twopi*(np.inner(Uniq,(dXdata+Xdata).T).T+Phi.T).T
805        sinp = np.sin(phase)
806        cosp = np.cos(phase)
807        biso = -SQfactor*Uisodata[:,nxs]
808        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),len(SGT)*len(TwinLaw),axis=1).T
809        HbH = -np.sum(Uniq.T*np.swapaxes(np.inner(bij,Uniq),2,-1),axis=1)
810        Tuij = np.where(HbH<1.,np.exp(HbH),1.0).T
811        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/len(SGMT)
812        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
813        FF = np.repeat(refDict['FF']['FF'][iBeg:iFin].T[Tindx].T,len(SGT)*len(TwinLaw),axis=0)
814        Bab = np.repeat(parmDict[phfx+'BabA']*np.exp(-parmDict[phfx+'BabU']*SQfactor),len(SGT)*len(TwinLaw))
815        if 'T' in calcControls[hfx+'histType']: #fa,fb are 2 X blkSize X nTwin X nOps x nAtoms
816            fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-np.reshape(Flack*FPP,sinp.shape)*sinp*Tcorr])
817            fb = np.array([np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr,np.reshape(Flack*FPP,cosp.shape)*cosp*Tcorr])
818        else:
819            fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-Flack*FPP*sinp*Tcorr])
820            fb = np.array([np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr,Flack*FPP*cosp*Tcorr])
821        fas = np.sum(np.sum(fa,axis=-1),axis=-1)  #real 2 x blkSize x nTwin; sum over atoms & uniq hkl
822        fbs = np.sum(np.sum(fb,axis=-1),axis=-1)  #imag
823        if SGData['SGInv']: #centrosymmetric; B=0
824            fbs[0] *= 0.
825            fas[1] *= 0.
826        if 'P' in calcControls[hfx+'histType']:     #PXC, PNC & PNT: F^2 = A[0]^2 + A[1]^2 + B[0]^2 + B[1]^2
827            refl.T[9] = np.sum(fas**2,axis=0)+np.sum(fbs**2,axis=0) #add fam**2 & fbm**2 here   
828            refl.T[10] = atan2d(fbs[0],fas[0])  #ignore f' & f"
829        else:                                       #HKLF: F^2 = (A[0]+A[1])^2 + (B[0]+B[1])^2
830            if len(TwinLaw) > 1:
831                refl.T[9] = np.sum(fas[:,:,0],axis=0)**2+np.sum(fbs[:,:,0],axis=0)**2   #FcT from primary twin element
832                refl.T[7] = np.sum(TwinFr*TwMask*np.sum(fas,axis=0)**2,axis=-1)+   \
833                    np.sum(TwinFr*TwMask*np.sum(fbs,axis=0)**2,axis=-1)                        #Fc sum over twins
834                refl.T[10] = atan2d(fbs[0].T[0],fas[0].T[0])  #ignore f' & f" & use primary twin
835            else:   # checked correct!!
836                refl.T[9] = np.sum(fas,axis=0)**2+np.sum(fbs,axis=0)**2
837                refl.T[7] = np.copy(refl.T[9])               
838                refl.T[10] = atan2d(fbs[0],fas[0])  #ignore f' & f"
839#                refl.T[10] = atan2d(np.sum(fbs,axis=0),np.sum(fas,axis=0)) #include f' & f"
840        iBeg += blkSize
841#    print 'sf time %.4f, nref %d, blkSize %d'%(time.time()-time0,nRef,blkSize)
842   
843def StructureFactorDerv2(refDict,G,hfx,pfx,SGData,calcControls,parmDict):
844    '''Compute structure factor derivatives on blocks of reflections - for powders/nontwins only
845    faster than StructureFactorDerv - correct for powders/nontwins!!
846    input:
847   
848    :param dict refDict: where
849        'RefList' list where each ref = h,k,l,it,d,...
850        'FF' dict of form factors - filled in below
851    :param np.array G:      reciprocal metric tensor
852    :param str hfx:    histogram id string
853    :param str pfx:    phase id string
854    :param dict SGData: space group info. dictionary output from SpcGroup
855    :param dict calcControls:
856    :param dict parmDict:
857   
858    :returns: dict dFdvDict: dictionary of derivatives
859    '''
860    phfx = pfx.split(':')[0]+hfx
861    ast = np.sqrt(np.diag(G))
862    Mast = twopisq*np.multiply.outer(ast,ast)
863    SGMT = np.array([ops[0] for ops in SGData['SGOps']])
864    SGT = np.array([ops[1] for ops in SGData['SGOps']])
865    FFtables = calcControls['FFtables']
866    BLtables = calcControls['BLtables']
867    Amat,Bmat = G2lat.Gmat2AB(G)
868    nRef = len(refDict['RefList'])
869    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
870        GetAtomFXU(pfx,calcControls,parmDict)
871    if not Xdata.size:          #no atoms in phase!
872        return {}
873    mSize = len(Mdata)
874    FF = np.zeros(len(Tdata))
875    if 'NC' in calcControls[hfx+'histType']:
876        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
877    elif 'X' in calcControls[hfx+'histType']:
878        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
879        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
880    Uij = np.array(G2lat.U6toUij(Uijdata))
881    bij = Mast*Uij.T
882    dFdvDict = {}
883    dFdfr = np.zeros((nRef,mSize))
884    dFdx = np.zeros((nRef,mSize,3))
885    dFdui = np.zeros((nRef,mSize))
886    dFdua = np.zeros((nRef,mSize,6))
887    dFdbab = np.zeros((nRef,2))
888    dFdfl = np.zeros((nRef))
889    Flack = 1.0
890    if not SGData['SGInv'] and 'S' in calcControls[hfx+'histType'] and phfx+'Flack' in parmDict:
891        Flack = 1.-2.*parmDict[phfx+'Flack']
892#    time0 = time.time()
893#reflection processing begins here - big arrays!
894    iBeg = 0
895    blkSize = 32       #no. of reflections in a block - optimized for speed
896    while iBeg < nRef:
897        iFin = min(iBeg+blkSize,nRef)
898        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
899        H = refl.T[:3].T
900        SQ = 1./(2.*refl.T[4])**2             # or (sin(theta)/lambda)**2
901        SQfactor = 8.0*SQ*np.pi**2
902        if 'T' in calcControls[hfx+'histType']:
903            if 'P' in calcControls[hfx+'histType']:
904                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[14])
905            else:
906                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[12])
907            FP = np.repeat(FP.T,len(SGT),axis=0)
908            FPP = np.repeat(FPP.T,len(SGT),axis=0)
909        dBabdA = np.exp(-parmDict[phfx+'BabU']*SQfactor)
910        Bab = np.repeat(parmDict[phfx+'BabA']*np.exp(-parmDict[phfx+'BabU']*SQfactor),len(SGT))
911        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
912        FF = np.repeat(refDict['FF']['FF'][iBeg:iFin].T[Tindx].T,len(SGT),axis=0)
913        Uniq = np.inner(H,SGMT)             # array(nSGOp,3)
914        Phi = np.inner(H,SGT)
915        phase = twopi*(np.inner(Uniq,(dXdata+Xdata).T).T+Phi.T).T
916        sinp = np.sin(phase)        #refBlk x nOps x nAtoms
917        cosp = np.cos(phase)
918        occ = Mdata*Fdata/len(SGT)
919        biso = -SQfactor*Uisodata[:,nxs]
920        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),len(SGT),axis=1).T
921        HbH = -np.sum(Uniq.T*np.swapaxes(np.inner(bij,Uniq),2,-1),axis=1)
922        Tuij = np.where(HbH<1.,np.exp(HbH),1.0).T
923        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/len(SGMT)
924        Hij = np.array([Mast*np.multiply.outer(U,U) for U in np.reshape(Uniq,(-1,3))])      #Nref*Nops,3,3
925        Hij = np.reshape(np.array([G2lat.UijtoU6(uij) for uij in Hij]),(-1,len(SGT),6))     #Nref,Nops,6
926        fot = np.reshape(((FF+FP).T-Bab).T,cosp.shape)*Tcorr
927        if len(FPP.shape) > 1:
928            fotp = np.reshape(FPP,cosp.shape)*Tcorr
929        else:
930            fotp = FPP*Tcorr     
931        if 'T' in calcControls[hfx+'histType']:
932            fa = np.array([fot*cosp,-np.reshape(Flack*FPP,sinp.shape)*sinp*Tcorr])
933            fb = np.array([fot*sinp,np.reshape(Flack*FPP,cosp.shape)*cosp*Tcorr])
934        else:
935            fa = np.array([fot*cosp,-Flack*FPP*sinp*Tcorr])
936            fb = np.array([fot*sinp,Flack*FPP*cosp*Tcorr])
937        fas = np.sum(np.sum(fa,axis=-1),axis=-1)      #real sum over atoms & unique hkl array(2,refBlk,nTwins)
938        fbs = np.sum(np.sum(fb,axis=-1),axis=-1)      #imag sum over atoms & uniq hkl
939        fax = np.array([-fot*sinp,-fotp*cosp])   #positions array(2,refBlk,nEqv,nAtoms)
940        fbx = np.array([fot*cosp,-fotp*sinp])
941        #sum below is over Uniq
942        dfadfr = np.sum(fa/occ,axis=-2)        #array(2,refBlk,nAtom) Fdata != 0 avoids /0. problem
943        dfadba = np.sum(-cosp*Tcorr,axis=-2)  #array(refBlk,nAtom)
944        dfadx = np.sum(twopi*Uniq[nxs,:,nxs,:,:]*np.swapaxes(fax,-2,-1)[:,:,:,:,nxs],axis=-2)
945        dfadui = np.sum(-SQfactor[nxs,:,nxs,nxs]*fa,axis=-2) #array(Ops,refBlk,nAtoms)
946        dfadua = np.sum(-Hij[nxs,:,nxs,:,:]*np.swapaxes(fa,-2,-1)[:,:,:,:,nxs],axis=-2)
947        # array(2,refBlk,nAtom,3) & array(2,refBlk,nAtom,6)
948        if not SGData['SGInv']:
949            dfbdfr = np.sum(fb/occ,axis=-2)        #Fdata != 0 avoids /0. problem
950            dfbdba = np.sum(-sinp*Tcorr,axis=-2)
951            dfadfl = np.sum(np.sum(-fotp*sinp,axis=-1),axis=-1)
952            dfbdfl = np.sum(np.sum(fotp*cosp,axis=-1),axis=-1)
953            dfbdx = np.sum(twopi*Uniq[nxs,:,nxs,:,:]*np.swapaxes(fbx,-2,-1)[:,:,:,:,nxs],axis=-2)           
954            dfbdui = np.sum(-SQfactor[nxs,:,nxs,nxs]*fb,axis=-2)
955            dfbdua = np.sum(-Hij[nxs,:,nxs,:,:]*np.swapaxes(fb,-2,-1)[:,:,:,:,nxs],axis=-2)
956        else:
957            dfbdfr = np.zeros_like(dfadfr)
958            dfbdx = np.zeros_like(dfadx)
959            dfbdui = np.zeros_like(dfadui)
960            dfbdua = np.zeros_like(dfadua)
961            dfbdba = np.zeros_like(dfadba)
962            dfadfl = 0.0
963            dfbdfl = 0.0
964        #NB: the above have been checked against PA(1:10,1:2) in strfctr.for for Al2O3!   
965        SA = fas[0]+fas[1]
966        SB = fbs[0]+fbs[1]
967        if 'P' in calcControls[hfx+'histType']: #checked perfect for centro & noncentro
968            dFdfr[iBeg:iFin] = 2.*np.sum(fas[:,:,nxs]*dfadfr+fbs[:,:,nxs]*dfbdfr,axis=0)*Mdata/len(SGMT)
969            dFdx[iBeg:iFin] = 2.*np.sum(fas[:,:,nxs,nxs]*dfadx+fbs[:,:,nxs,nxs]*dfbdx,axis=0)
970            dFdui[iBeg:iFin] = 2.*np.sum(fas[:,:,nxs]*dfadui+fbs[:,:,nxs]*dfbdui,axis=0)
971            dFdua[iBeg:iFin] = 2.*np.sum(fas[:,:,nxs,nxs]*dfadua+fbs[:,:,nxs,nxs]*dfbdua,axis=0)
972        else:
973            dFdfr[iBeg:iFin] = (2.*SA[:,nxs]*(dfadfr[0]+dfadfr[1])+2.*SB[:,nxs]*(dfbdfr[0]+dfbdfr[1]))*Mdata/len(SGMT)
974            dFdx[iBeg:iFin] = 2.*SA[:,nxs,nxs]*(dfadx[0]+dfadx[1])+2.*SB[:,nxs,nxs]*(dfbdx[0]+dfbdx[1])
975            dFdui[iBeg:iFin] = 2.*SA[:,nxs]*(dfadui[0]+dfadui[1])+2.*SB[:,nxs]*(dfbdui[0]+dfbdui[1])
976            dFdua[iBeg:iFin] = 2.*SA[:,nxs,nxs]*(dfadua[0]+dfadua[1])+2.*SB[:,nxs,nxs]*(dfbdua[0]+dfbdua[1])
977            dFdfl[iBeg:iFin] = -SA*dfadfl-SB*dfbdfl  #array(nRef,)
978        dFdbab[iBeg:iFin] = 2.*(fas[0,nxs]*np.array([np.sum(dfadba.T*dBabdA,axis=0),np.sum(-dfadba.T*parmDict[phfx+'BabA']*SQfactor*dBabdA,axis=0)])+ \
979                            fbs[0,nxs]*np.array([np.sum(dfbdba.T*dBabdA,axis=0),np.sum(-dfbdba.T*parmDict[phfx+'BabA']*SQfactor*dBabdA,axis=0)])).T
980        iBeg += blkSize
981#    print 'derv time %.4f, nref %d, blkSize %d'%(time.time()-time0,nRef,blkSize)
982        #loop over atoms - each dict entry is list of derivatives for all the reflections
983    for i in range(len(Mdata)):
984        dFdvDict[pfx+'Afrac:'+str(i)] = dFdfr.T[i]
985        dFdvDict[pfx+'dAx:'+str(i)] = dFdx.T[0][i]
986        dFdvDict[pfx+'dAy:'+str(i)] = dFdx.T[1][i]
987        dFdvDict[pfx+'dAz:'+str(i)] = dFdx.T[2][i]
988        dFdvDict[pfx+'AUiso:'+str(i)] = dFdui.T[i]
989        dFdvDict[pfx+'AU11:'+str(i)] = dFdua.T[0][i]
990        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
991        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
992        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
993        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
994        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
995    dFdvDict[phfx+'Flack'] = 4.*dFdfl.T
996    dFdvDict[phfx+'BabA'] = dFdbab.T[0]
997    dFdvDict[phfx+'BabU'] = dFdbab.T[1]
998    return dFdvDict
999   
1000def MagStructureFactor2(refDict,G,hfx,pfx,SGData,calcControls,parmDict):
1001    ''' Compute neutron magnetic structure factors for all h,k,l for phase
1002    puts the result, F^2, in each ref[8] in refList
1003    operates on blocks of 100 reflections for speed
1004    input:
1005   
1006    :param dict refDict: where
1007        'RefList' list where each ref = h,k,l,it,d,...
1008        'FF' dict of form factors - filed in below
1009    :param np.array G:      reciprocal metric tensor
1010    :param str pfx:    phase id string
1011    :param dict SGData: space group info. dictionary output from SpcGroup
1012    :param dict calcControls:
1013    :param dict ParmDict:
1014       
1015    :returns: copy of new refList - used in calculating numerical derivatives
1016
1017    '''       
1018    g = nl.inv(G)
1019    ast = np.sqrt(np.diag(G))
1020    ainv = np.sqrt(np.diag(g))
1021    GS = G/np.outer(ast,ast)
1022    Ginv = g/np.outer(ainv,ainv)
1023    uAmat = G2lat.Gmat2AB(GS)[0]
1024    Mast = twopisq*np.multiply.outer(ast,ast)
1025    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
1026    SGT = np.array([ops[1] for ops in SGData['SGOps']])
1027    Ncen = len(SGData['SGCen'])
1028    Nops = len(SGMT)*Ncen
1029    if not SGData['SGFixed']:
1030        Nops *= (1+SGData['SGInv'])
1031    MFtables = calcControls['MFtables']
1032    Bmat = G2lat.Gmat2AB(G)[1]
1033    TwinLaw = np.ones(1)
1034#    TwinLaw = np.array([[[1,0,0],[0,1,0],[0,0,1]],])
1035#    TwDict = refDict.get('TwDict',{})           
1036#    if 'S' in calcControls[hfx+'histType']:
1037#        NTL = calcControls[phfx+'NTL']
1038#        NM = calcControls[phfx+'TwinNMN']+1
1039#        TwinLaw = calcControls[phfx+'TwinLaw']
1040#        TwinFr = np.array([parmDict[phfx+'TwinFr:'+str(i)] for i in range(len(TwinLaw))])
1041#        TwinInv = list(np.where(calcControls[phfx+'TwinInv'],-1,1))
1042    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
1043        GetAtomFXU(pfx,calcControls,parmDict)
1044    if not Xdata.size:          #no atoms in phase!
1045        return
1046    Mag = np.array([np.sqrt(np.inner(mag,np.inner(mag,Ginv))) for mag in Gdata.T])
1047    Gdata = np.inner(Gdata.T,np.swapaxes(SGMT,1,2)).T            #apply sym. ops.
1048    if SGData['SGInv'] and not SGData['SGFixed']:
1049        Gdata = np.hstack((Gdata,-Gdata))       #inversion if any
1050    Gdata = np.hstack([Gdata for icen in range(Ncen)])        #dup over cell centering--> [Mxyz,nops,natms]
1051    Gdata = SGData['MagMom'][nxs,:,nxs]*Gdata   #flip vectors according to spin flip * det(opM)
1052    Mag = np.tile(Mag[:,nxs],Nops).#make Mag same length as Gdata
1053    Kdata = np.inner(Gdata.T,uAmat).T     #Cartesian unit vectors
1054    Kmean = np.mean(np.sqrt(np.sum(Kdata**2,axis=0)),axis=0)
1055    Kdata /= Kmean
1056    Uij = np.array(G2lat.U6toUij(Uijdata))
1057    bij = Mast*Uij.T
1058    blkSize = 100       #no. of reflections in a block - size seems optimal
1059    nRef = refDict['RefList'].shape[0]
1060    SQ = 1./(2.*refDict['RefList'].T[4])**2
1061    refDict['FF']['El'] = list(MFtables.keys())
1062    refDict['FF']['MF'] = np.zeros((nRef,len(MFtables)))
1063    for iel,El in enumerate(refDict['FF']['El']):
1064        refDict['FF']['MF'].T[iel] = G2el.MagScatFac(MFtables[El],SQ)
1065#reflection processing begins here - big arrays!
1066    iBeg = 0
1067    while iBeg < nRef:
1068        iFin = min(iBeg+blkSize,nRef)
1069        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
1070        H = refl.T[:3].T                          #array(blkSize,3)
1071#        H = np.squeeze(np.inner(H.T,TwinLaw))   #maybe array(blkSize,nTwins,3) or (blkSize,3)
1072#        TwMask = np.any(H,axis=-1)
1073#        if TwinLaw.shape[0] > 1 and TwDict: #need np.inner(TwinLaw[?],TwDict[iref][i])*TwinInv[i]
1074#            for ir in range(blkSize):
1075#                iref = ir+iBeg
1076#                if iref in TwDict:
1077#                    for i in TwDict[iref]:
1078#                        for n in range(NTL):
1079#                            H[ir][i+n*NM] = np.inner(TwinLaw[n*NM],np.array(TwDict[iref][i])*TwinInv[i+n*NM])
1080#            TwMask = np.any(H,axis=-1)
1081        SQ = 1./(2.*refl.T[4])**2               #array(blkSize)
1082        SQfactor = 4.0*SQ*twopisq               #ditto prev.
1083        Uniq = np.inner(H,SGMT)
1084        Phi = np.inner(H,SGT)
1085        phase = twopi*(np.inner(Uniq,(dXdata+Xdata).T).T+Phi.T).T
1086        biso = -SQfactor*Uisodata[:,nxs]
1087        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),len(SGT)*len(TwinLaw),axis=1).T
1088        HbH = -np.sum(Uniq.T*np.swapaxes(np.inner(bij,Uniq),2,-1),axis=1)
1089        Tuij = np.where(HbH<1.,np.exp(HbH),1.0).T
1090        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
1091        MF = refDict['FF']['MF'][iBeg:iFin].T[Tindx].T   #Nref,Natm
1092        TMcorr = 0.539*(np.reshape(Tiso,Tuij.shape)*Tuij)[:,0,:]*Fdata*Mdata*MF/(2*Nops)     #Nref,Natm
1093        if SGData['SGInv']:
1094            if not SGData['SGFixed']:
1095                mphase = np.hstack((phase,-phase))  #OK
1096            else:
1097                mphase = phase
1098        else:
1099            mphase = phase                    #
1100        mphase = np.array([mphase+twopi*np.inner(cen,H)[:,nxs,nxs] for cen in SGData['SGCen']])
1101        mphase = np.concatenate(mphase,axis=1)              #Nref,full Nop,Natm
1102        sinm = np.sin(mphase)                               #ditto - match magstrfc.for
1103        cosm = np.cos(mphase)                               #ditto
1104        HM = np.inner(Bmat.T,H)                             #put into cartesian space
1105        HM = HM/np.sqrt(np.sum(HM**2,axis=0))               #Kdata = MAGS & HM = UVEC in magstrfc.for both OK
1106        eDotK = np.sum(HM[:,:,nxs,nxs]*Kdata[:,nxs,:,:],axis=0)
1107        Q = HM[:,:,nxs,nxs]*eDotK[nxs,:,:,:]-Kdata[:,nxs,:,:] #xyz,Nref,Nop,Natm = BPM in magstrfc.for OK
1108        fam = Q*TMcorr[nxs,:,nxs,:]*cosm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #ditto
1109        fbm = Q*TMcorr[nxs,:,nxs,:]*sinm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #ditto
1110        fams = np.sum(np.sum(fam,axis=-1),axis=-1)     #Mxyz,Nref  Sum(sum(fam,atoms),ops)
1111        fbms = np.sum(np.sum(fbm,axis=-1),axis=-1)     #ditto
1112        refl.T[9] = np.sum(fams**2,axis=0)+np.sum(fbms**2,axis=0)   #Sum(fams**2,Mxyz) Re + Im
1113        refl.T[7] = np.copy(refl.T[9])               
1114        refl.T[10] = atan2d(fbms[0],fams[0]) #- what is phase for mag refl?
1115#        if 'P' in calcControls[hfx+'histType']:     #PXC, PNC & PNT: F^2 = A[0]^2 + A[1]^2 + B[0]^2 + B[1]^2
1116#            refl.T[9] = np.sum(fas**2,axis=0)+np.sum(fbs**2,axis=0) #add fam**2 & fbm**2 here   
1117#            refl.T[10] = atan2d(fbs[0],fas[0])  #ignore f' & f"
1118#        else:                                       #HKLF: F^2 = (A[0]+A[1])^2 + (B[0]+B[1])^2
1119#            if len(TwinLaw) > 1:
1120#                refl.T[9] = np.sum(fas[:,:,0],axis=0)**2+np.sum(fbs[:,:,0],axis=0)**2   #FcT from primary twin element
1121#                refl.T[7] = np.sum(TwinFr*TwMask*np.sum(fas,axis=0)**2,axis=-1)+   \
1122#                    np.sum(TwinFr*TwMask*np.sum(fbs,axis=0)**2,axis=-1)                        #Fc sum over twins
1123#                refl.T[10] = atan2d(fbs[0].T[0],fas[0].T[0])  #ignore f' & f" & use primary twin
1124#            else:   # checked correct!!
1125#                refl.T[9] = np.sum(fas,axis=0)**2+np.sum(fbs,axis=0)**2
1126#                refl.T[7] = np.copy(refl.T[9])               
1127#                refl.T[10] = atan2d(fbs[0],fas[0])  #ignore f' & f"
1128##                refl.T[10] = atan2d(np.sum(fbs,axis=0),np.sum(fas,axis=0)) #include f' & f"
1129        iBeg += blkSize
1130#    print 'sf time %.4f, nref %d, blkSize %d'%(time.time()-time0,nRef,blkSize)
1131    return copy.deepcopy(refDict['RefList'])
1132
1133def MagStructureFactorDerv2(refDict,G,hfx,pfx,SGData,calcControls,parmDict):
1134    '''Compute magnetic structure factor derivatives numerically - for powders/nontwins only
1135    input:
1136   
1137    :param dict refDict: where
1138        'RefList' list where each ref = h,k,l,it,d,...
1139        'FF' dict of form factors - filled in below
1140    :param np.array G:      reciprocal metric tensor
1141    :param str hfx:    histogram id string
1142    :param str pfx:    phase id string
1143    :param dict SGData: space group info. dictionary output from SpcGroup
1144    :param dict calcControls:
1145    :param dict parmDict:
1146   
1147    :returns: dict dFdvDict: dictionary of magnetic derivatives
1148    '''
1149   
1150    trefDict = copy.deepcopy(refDict)
1151    dM = 1.e-6
1152    dFdvDict = {}
1153    for parm in parmDict:
1154        if 'AM' in parm:
1155            parmDict[parm] += dM
1156            prefList = MagStructureFactor2(trefDict,G,hfx,pfx,SGData,calcControls,parmDict)
1157            parmDict[parm] -= 2*dM
1158            mrefList = MagStructureFactor2(trefDict,G,hfx,pfx,SGData,calcControls,parmDict)
1159            parmDict[parm] += dM
1160            dFdvDict[parm] = (prefList[:,9]-mrefList[:,9])/(2.*dM)
1161    return dFdvDict
1162           
1163def MagStructureFactorDerv(refDict,G,hfx,pfx,SGData,calcControls,parmDict):
1164    '''Compute nonmagnetic structure factor derivatives on blocks of reflections in magnetic structures - for powders/nontwins only
1165    input:
1166   
1167    :param dict refDict: where
1168        'RefList' list where each ref = h,k,l,it,d,...
1169        'FF' dict of form factors - filled in below
1170    :param np.array G:      reciprocal metric tensor
1171    :param str hfx:    histogram id string
1172    :param str pfx:    phase id string
1173    :param dict SGData: space group info. dictionary output from SpcGroup
1174    :param dict calcControls:
1175    :param dict parmDict:
1176   
1177    :returns: dict dFdvDict: dictionary of derivatives
1178    '''
1179   
1180    g = nl.inv(G)
1181    ast = np.sqrt(np.diag(G))
1182    ainv = np.sqrt(np.diag(g))
1183    GS = G/np.outer(ast,ast)
1184    Ginv = g/np.outer(ainv,ainv)
1185    uAmat = G2lat.Gmat2AB(GS)[0]
1186    Mast = twopisq*np.multiply.outer(ast,ast)
1187    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
1188    SGT = np.array([ops[1] for ops in SGData['SGOps']])
1189    Ncen = len(SGData['SGCen'])
1190    Nops = len(SGMT)*Ncen
1191    if not SGData['SGFixed']:
1192        Nops *= (1+SGData['SGInv'])
1193    Bmat = G2lat.Gmat2AB(G)[1]
1194    nRef = len(refDict['RefList'])
1195    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
1196        GetAtomFXU(pfx,calcControls,parmDict)
1197    if not Xdata.size:          #no atoms in phase!
1198        return {}
1199    mSize = len(Mdata)
1200    Mag = np.array([np.sqrt(np.inner(mag,np.inner(mag,Ginv))) for mag in Gdata.T])
1201    Gones = np.ones_like(Gdata)
1202    Gdata = np.inner(Gdata.T,np.swapaxes(SGMT,1,2)).T            #apply sym. ops.
1203    Gones = np.inner(Gones.T,SGMT).T
1204    if SGData['SGInv'] and not SGData['SGFixed']:
1205        Gdata = np.hstack((Gdata,-Gdata))       #inversion if any
1206        Gones = np.hstack((Gones,-Gones))       #inversion if any
1207    Gdata = np.hstack([Gdata for icen in range(Ncen)])        #dup over cell centering
1208    Gones = np.hstack([Gones for icen in range(Ncen)])        #dup over cell centering
1209    Gdata = SGData['MagMom'][nxs,:,nxs]*Gdata   #flip vectors according to spin flip
1210    Gones = SGData['MagMom'][nxs,:,nxs]*Gones   #flip vectors according to spin flip
1211    Mag = np.tile(Mag[:,nxs],Nops).#make Mag same length as Gdata
1212    Kdata = np.inner(Gdata.T,uAmat).T     #Cartesian unit vectors
1213    Kmean = np.mean(np.sqrt(np.sum(Kdata**2,axis=0)),axis=0)
1214    Kdata /= Kmean
1215    Uij = np.array(G2lat.U6toUij(Uijdata))
1216    bij = Mast*Uij.T
1217    dFdvDict = {}
1218    dFdfr = np.zeros((nRef,mSize))
1219    dFdx = np.zeros((nRef,mSize,3))
1220    dFdui = np.zeros((nRef,mSize))
1221    dFdua = np.zeros((nRef,mSize,6))
1222    time0 = time.time()
1223#reflection processing begins here - big arrays!
1224    iBeg = 0
1225    blkSize = 5       #no. of reflections in a block - optimized for speed
1226    while iBeg < nRef:
1227        iFin = min(iBeg+blkSize,nRef)
1228        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
1229        H = refl.T[:3].T
1230        SQ = 1./(2.*refl.T[4])**2             # or (sin(theta)/lambda)**2
1231        SQfactor = 8.0*SQ*np.pi**2
1232        Uniq = np.inner(H,SGMT)             # array(nSGOp,3)
1233        Phi = np.inner(H,SGT)
1234        phase = twopi*(np.inner(Uniq,(dXdata+Xdata).T).T+Phi.T).T
1235        occ = Mdata*Fdata/Nops
1236        biso = -SQfactor*Uisodata[:,nxs]
1237        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),len(SGT),axis=1).T
1238        HbH = -np.sum(Uniq.T*np.swapaxes(np.inner(bij,Uniq),2,-1),axis=1)
1239        Tuij = np.where(HbH<1.,np.exp(HbH),1.0).T
1240        Hij = np.array([Mast*np.multiply.outer(U,U) for U in np.reshape(Uniq,(-1,3))])
1241        Hij = np.reshape(np.array([G2lat.UijtoU6(uij) for uij in Hij]),(-1,len(SGT),6))
1242        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
1243        MF = refDict['FF']['MF'][iBeg:iFin].T[Tindx].T   #Nref,Natm
1244        TMcorr = 0.539*(np.reshape(Tiso,Tuij.shape)*Tuij)[:,0,:]*Fdata*Mdata*MF/(2*Nops)     #Nref,Natm
1245        if SGData['SGInv']:
1246            if not SGData['SGFixed']:
1247                mphase = np.hstack((phase,-phase))  #OK
1248                Uniq = np.hstack((Uniq,-Uniq))      #Nref,Nops,hkl
1249                Hij = np.hstack((Hij,Hij))
1250            else:
1251                mphase = phase
1252        else:
1253            mphase = phase                    #
1254        Hij = np.concatenate(np.array([Hij for cen in SGData['SGCen']]),axis=1)
1255        Uniq = np.hstack([Uniq for cen in SGData['SGCen']])
1256        mphase = np.array([mphase+twopi*np.inner(cen,H)[:,nxs,nxs] for cen in SGData['SGCen']])
1257        mphase = np.concatenate(mphase,axis=1)              #Nref,Nop,Natm
1258        sinm = np.sin(mphase)                               #ditto - match magstrfc.for
1259        cosm = np.cos(mphase)                               #ditto
1260        HM = np.inner(Bmat.T,H)                             #put into cartesian space
1261        HM = HM/np.sqrt(np.sum(HM**2,axis=0))               #unit cartesian vector for H
1262        eDotK = np.sum(HM[:,:,nxs,nxs]*Kdata[:,nxs,:,:],axis=0)
1263        Q = HM[:,:,nxs,nxs]*eDotK[nxs,:,:,:]-Kdata[:,nxs,:,:] #Mxyz,Nref,Nop,Natm = BPM in magstrfc.for OK
1264       
1265        fam = Q*TMcorr[nxs,:,nxs,:]*cosm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #Mxyz,Nref,Nop,Natm
1266        fbm = Q*TMcorr[nxs,:,nxs,:]*sinm[nxs,:,:,:]*Mag[nxs,nxs,:,:]
1267        fams = np.sum(np.sum(fam,axis=-1),axis=-1)                      #Mxyz,Nref
1268        fbms = np.sum(np.sum(fbm,axis=-1),axis=-1)
1269        famx = -Q*TMcorr[nxs,:,nxs,:]*Mag[nxs,nxs,:,:]*sinm[nxs,:,:,:]   #Mxyz,Nref,Nops,Natom
1270        fbmx = Q*TMcorr[nxs,:,nxs,:]*Mag[nxs,nxs,:,:]*cosm[nxs,:,:,:]
1271        #sums below are over Nops - real part
1272        dfadfr = np.sum(fam/occ,axis=2)        #array(Mxyz,refBlk,nAtom) Fdata != 0 avoids /0. problem deriv OK
1273        dfadx = np.sum(twopi*Uniq[nxs,:,:,nxs,:]*famx[:,:,:,:,nxs],axis=2)          #deriv OK
1274        dfadui = np.sum(-SQfactor[:,nxs,nxs]*fam,axis=2) #array(Ops,refBlk,nAtoms)  deriv OK
1275        dfadua = np.sum(-Hij[nxs,:,:,nxs,:]*fam[:,:,:,:,nxs],axis=2)            #deriv OK
1276        # imaginary part; array(3,refBlk,nAtom,3) & array(3,refBlk,nAtom,6)
1277        dfbdfr = np.sum(fbm/occ,axis=2)        #array(mxyz,refBlk,nAtom) Fdata != 0 avoids /0. problem
1278        dfbdx = np.sum(twopi*Uniq[nxs,:,:,nxs,:]*fbmx[:,:,:,:,nxs],axis=2)
1279        dfbdui = np.sum(-SQfactor[:,nxs,nxs]*fbm,axis=2) #array(Ops,refBlk,nAtoms)
1280        dfbdua = np.sum(-Hij[nxs,:,:,nxs,:]*fbm[:,:,:,:,nxs],axis=2)
1281        #accumulate derivatives   
1282        dFdfr[iBeg:iFin] = 2.*np.sum((fams[:,:,nxs]*dfadfr+fbms[:,:,nxs]*dfbdfr)*Mdata/Nops,axis=0) #ok
1283        dFdx[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs,nxs]*dfadx+fbms[:,:,nxs,nxs]*dfbdx,axis=0)         #ok
1284        dFdui[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs]*dfadui+fbms[:,:,nxs]*dfbdui,axis=0)              #ok
1285        dFdua[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs,nxs]*dfadua+fbms[:,:,nxs,nxs]*dfbdua,axis=0)      #ok
1286        iBeg += blkSize
1287    print (' %d derivative time %.4f\r'%(nRef,time.time()-time0))
1288        #loop over atoms - each dict entry is list of derivatives for all the reflections
1289    for i in range(len(Mdata)):
1290        dFdvDict[pfx+'Afrac:'+str(i)] = dFdfr.T[i]
1291        dFdvDict[pfx+'dAx:'+str(i)] = dFdx.T[0][i]
1292        dFdvDict[pfx+'dAy:'+str(i)] = dFdx.T[1][i]
1293        dFdvDict[pfx+'dAz:'+str(i)] = dFdx.T[2][i]
1294        dFdvDict[pfx+'AUiso:'+str(i)] = dFdui.T[i]
1295        dFdvDict[pfx+'AU11:'+str(i)] = dFdua.T[0][i]
1296        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
1297        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
1298        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
1299        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
1300        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
1301    return dFdvDict
1302       
1303def StructureFactorDervTw2(refDict,G,hfx,pfx,SGData,calcControls,parmDict):
1304    '''Compute structure factor derivatives on blocks of reflections - for twins only
1305    faster than StructureFactorDervTw
1306    input:
1307   
1308    :param dict refDict: where
1309        'RefList' list where each ref = h,k,l,it,d,...
1310        'FF' dict of form factors - filled in below
1311    :param np.array G:      reciprocal metric tensor
1312    :param str hfx:    histogram id string
1313    :param str pfx:    phase id string
1314    :param dict SGData: space group info. dictionary output from SpcGroup
1315    :param dict calcControls:
1316    :param dict parmDict:
1317   
1318    :returns: dict dFdvDict: dictionary of derivatives
1319    '''
1320    phfx = pfx.split(':')[0]+hfx
1321    ast = np.sqrt(np.diag(G))
1322    Mast = twopisq*np.multiply.outer(ast,ast)
1323    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
1324    SGT = np.array([ops[1] for ops in SGData['SGOps']])
1325    FFtables = calcControls['FFtables']
1326    BLtables = calcControls['BLtables']
1327    TwDict = refDict.get('TwDict',{})           
1328    NTL = calcControls[phfx+'NTL']
1329    NM = calcControls[phfx+'TwinNMN']+1
1330    TwinLaw = calcControls[phfx+'TwinLaw']
1331    TwinFr = np.array([parmDict[phfx+'TwinFr:'+str(i)] for i in range(len(TwinLaw))])
1332    TwinInv = list(np.where(calcControls[phfx+'TwinInv'],-1,1))
1333    nTwin = len(TwinLaw)       
1334    nRef = len(refDict['RefList'])
1335    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
1336        GetAtomFXU(pfx,calcControls,parmDict)
1337    if not Xdata.size:          #no atoms in phase!
1338        return {}
1339    mSize = len(Mdata)
1340    FF = np.zeros(len(Tdata))
1341    if 'NC' in calcControls[hfx+'histType']:
1342        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
1343    elif 'X' in calcControls[hfx+'histType']:
1344        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
1345        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
1346    Uij = np.array(G2lat.U6toUij(Uijdata))
1347    bij = Mast*Uij.T
1348    dFdvDict = {}
1349    dFdfr = np.zeros((nRef,nTwin,mSize))
1350    dFdx = np.zeros((nRef,nTwin,mSize,3))
1351    dFdui = np.zeros((nRef,nTwin,mSize))
1352    dFdua = np.zeros((nRef,nTwin,mSize,6))
1353    dFdbab = np.zeros((nRef,nTwin,2))
1354    dFdtw = np.zeros((nRef,nTwin))
1355    time0 = time.time()
1356#reflection processing begins here - big arrays!
1357    iBeg = 0
1358    blkSize = 16       #no. of reflections in a block - optimized for speed
1359    while iBeg < nRef:
1360        iFin = min(iBeg+blkSize,nRef)
1361        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
1362        H = refl.T[:3]
1363        H = np.inner(H.T,TwinLaw)   #array(3,nTwins)
1364        TwMask = np.any(H,axis=-1)
1365        for ir in range(blkSize):
1366            iref = ir+iBeg
1367            if iref in TwDict:
1368                for i in TwDict[iref]:
1369                    for n in range(NTL):
1370                        H[ir][i+n*NM] = np.inner(TwinLaw[n*NM],np.array(TwDict[iref][i])*TwinInv[i+n*NM])
1371        TwMask = np.any(H,axis=-1)
1372        SQ = 1./(2.*refl.T[4])**2             # or (sin(theta)/lambda)**2
1373        SQfactor = 8.0*SQ*np.pi**2
1374        if 'T' in calcControls[hfx+'histType']:
1375            if 'P' in calcControls[hfx+'histType']:
1376                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[14])
1377            else:
1378                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[12])
1379            FP = np.repeat(FP.T,len(SGT)*len(TwinLaw),axis=0)
1380            FPP = np.repeat(FPP.T,len(SGT)*len(TwinLaw),axis=0)
1381        dBabdA = np.exp(-parmDict[phfx+'BabU']*SQfactor)
1382        Bab = np.repeat(parmDict[phfx+'BabA']*dBabdA,len(SGT)*nTwin)
1383        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
1384        FF = np.repeat(refDict['FF']['FF'][iBeg:iFin].T[Tindx].T,len(SGT)*len(TwinLaw),axis=0)
1385        Uniq = np.inner(H,SGMT)             # (nTwin,nSGOp,3)
1386        Phi = np.inner(H,SGT)
1387        phase = twopi*(np.inner(Uniq,(dXdata+Xdata).T).T+Phi.T).T
1388        sinp = np.sin(phase)
1389        cosp = np.cos(phase)
1390        occ = Mdata*Fdata/len(SGT)
1391        biso = -SQfactor*Uisodata[:,nxs]
1392        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),len(SGT)*nTwin,axis=1)
1393        HbH = -np.sum(Uniq.T*np.swapaxes(np.inner(bij,Uniq),2,-1),axis=1)
1394        Hij = np.array([Mast*np.multiply.outer(U,U) for U in np.reshape(Uniq,(-1,3))])
1395        Hij = np.reshape(np.array([G2lat.UijtoU6(uij) for uij in Hij]),(-1,nTwin,len(SGT),6))
1396        Tuij = np.where(HbH<1.,np.exp(HbH),1.0)
1397        Tcorr = (np.reshape(Tiso,Tuij.shape)*Tuij).T*Mdata*Fdata/len(SGMT)
1398        fot = np.reshape(((FF+FP).T-Bab).T,cosp.shape)*Tcorr
1399        fotp = FPP*Tcorr       
1400        if 'T' in calcControls[hfx+'histType']: #fa,fb are 2 X blkSize X nTwin X nOps x nAtoms
1401            fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-np.reshape(FPP,sinp.shape)*sinp*Tcorr])
1402            fb = np.array([np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr,np.reshape(FPP,cosp.shape)*cosp*Tcorr])
1403        else:
1404            fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-FPP*sinp*Tcorr])
1405            fb = np.array([np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr,FPP*cosp*Tcorr])
1406        fas = np.sum(np.sum(fa,axis=-1),axis=-1)      #real sum over atoms & unique hkl array(2,nTwins)
1407        fbs = np.sum(np.sum(fb,axis=-1),axis=-1)      #imag sum over atoms & uniq hkl
1408        if SGData['SGInv']: #centrosymmetric; B=0
1409            fbs[0] *= 0.
1410            fas[1] *= 0.
1411        fax = np.array([-fot*sinp,-fotp*cosp])   #positions array(2,nRef,ntwi,nEqv,nAtoms)
1412        fbx = np.array([fot*cosp,-fotp*sinp])
1413        #sum below is over Uniq
1414        dfadfr = np.sum(np.sum(fa/occ,axis=-2),axis=0)        #array(2,nRef,ntwin,nAtom) Fdata != 0 avoids /0. problem
1415        dfadba = np.sum(-cosp*Tcorr[:,nxs],axis=1)
1416        dfadui = np.sum(np.sum(-SQfactor[nxs,:,nxs,nxs,nxs]*fa,axis=-2),axis=0)           
1417        dfadx = np.sum(np.sum(twopi*Uniq[nxs,:,:,:,nxs,:]*fax[:,:,:,:,:,nxs],axis=-3),axis=0) # nRef x nTwin x nAtoms x xyz; sum on ops & A,A'
1418        dfadua = np.sum(np.sum(-Hij[nxs,:,:,:,nxs,:]*fa[:,:,:,:,:,nxs],axis=-3),axis=0) 
1419        if not SGData['SGInv']:
1420            dfbdfr = np.sum(np.sum(fb/occ,axis=-2),axis=0)        #Fdata != 0 avoids /0. problem
1421            dfadba /= 2.
1422#            dfbdba = np.sum(-sinp*Tcorr[:,nxs],axis=1)/2.
1423            dfbdui = np.sum(np.sum(-SQfactor[nxs,:,nxs,nxs,nxs]*fb,axis=-2),axis=0)
1424            dfbdx = np.sum(np.sum(twopi*Uniq[nxs,:,:,:,nxs,:]*fbx[:,:,:,:,:,nxs],axis=-3),axis=0)
1425            dfbdua = np.sum(np.sum(-Hij[nxs,:,:,:,nxs,:]*fb[:,:,:,:,:,nxs],axis=-3),axis=0)
1426        else:
1427            dfbdfr = np.zeros_like(dfadfr)
1428            dfbdx = np.zeros_like(dfadx)
1429            dfbdui = np.zeros_like(dfadui)
1430            dfbdua = np.zeros_like(dfadua)
1431#            dfbdba = np.zeros_like(dfadba)
1432        SA = fas[0]+fas[1]
1433        SB = fbs[0]+fbs[1]
1434        dFdfr[iBeg:iFin] = ((2.*TwMask*SA)[:,:,nxs]*dfadfr+(2.*TwMask*SB)[:,:,nxs]*dfbdfr)*Mdata[nxs,nxs,:]/len(SGMT)
1435        dFdx[iBeg:iFin] = (2.*TwMask*SA)[:,:,nxs,nxs]*dfadx+(2.*TwMask*SB)[:,:,nxs,nxs]*dfbdx
1436        dFdui[iBeg:iFin] = (2.*TwMask*SA)[:,:,nxs]*dfadui+(2.*TwMask*SB)[:,:,nxs]*dfbdui
1437        dFdua[iBeg:iFin] = (2.*TwMask*SA)[:,:,nxs,nxs]*dfadua+(2.*TwMask*SB)[:,:,nxs,nxs]*dfbdua
1438        if SGData['SGInv']: #centrosymmetric; B=0
1439            dFdtw[iBeg:iFin] = np.sum(TwMask[nxs,:]*fas,axis=0)**2
1440        else:               
1441            dFdtw[iBeg:iFin] = np.sum(TwMask[nxs,:]*fas,axis=0)**2+np.sum(TwMask[nxs,:]*fbs,axis=0)**2
1442#        dFdbab[iBeg:iFin] = fas[0,:,nxs]*np.array([np.sum(dfadba*dBabdA),np.sum(-dfadba*parmDict[phfx+'BabA']*SQfactor*dBabdA)]).T+ \
1443#            fbs[0,:,nxs]*np.array([np.sum(dfbdba*dBabdA),np.sum(-dfbdba*parmDict[phfx+'BabA']*SQfactor*dBabdA)]).T
1444        iBeg += blkSize
1445    print (' %d derivative time %.4f\r'%(len(refDict['RefList']),time.time()-time0))
1446    #loop over atoms - each dict entry is list of derivatives for all the reflections
1447    for i in range(len(Mdata)):     #these all OK
1448        dFdvDict[pfx+'Afrac:'+str(i)] = np.sum(dFdfr.T[i]*TwinFr[:,nxs],axis=0)
1449        dFdvDict[pfx+'dAx:'+str(i)] = np.sum(dFdx.T[0][i]*TwinFr[:,nxs],axis=0)
1450        dFdvDict[pfx+'dAy:'+str(i)] = np.sum(dFdx.T[1][i]*TwinFr[:,nxs],axis=0)
1451        dFdvDict[pfx+'dAz:'+str(i)] = np.sum(dFdx.T[2][i]*TwinFr[:,nxs],axis=0)
1452        dFdvDict[pfx+'AUiso:'+str(i)] = np.sum(dFdui.T[i]*TwinFr[:,nxs],axis=0)
1453        dFdvDict[pfx+'AU11:'+str(i)] = np.sum(dFdua.T[0][i]*TwinFr[:,nxs],axis=0)
1454        dFdvDict[pfx+'AU22:'+str(i)] = np.sum(dFdua.T[1][i]*TwinFr[:,nxs],axis=0)
1455        dFdvDict[pfx+'AU33:'+str(i)] = np.sum(dFdua.T[2][i]*TwinFr[:,nxs],axis=0)
1456        dFdvDict[pfx+'AU12:'+str(i)] = 2.*np.sum(dFdua.T[3][i]*TwinFr[:,nxs],axis=0)
1457        dFdvDict[pfx+'AU13:'+str(i)] = 2.*np.sum(dFdua.T[4][i]*TwinFr[:,nxs],axis=0)
1458        dFdvDict[pfx+'AU23:'+str(i)] = 2.*np.sum(dFdua.T[5][i]*TwinFr[:,nxs],axis=0)
1459    dFdvDict[phfx+'BabA'] = dFdbab.T[0]
1460    dFdvDict[phfx+'BabU'] = dFdbab.T[1]
1461    for i in range(nTwin):
1462        dFdvDict[phfx+'TwinFr:'+str(i)] = dFdtw.T[i]
1463    return dFdvDict
1464   
1465def SStructureFactor(refDict,G,hfx,pfx,SGData,SSGData,calcControls,parmDict):
1466    '''
1467    Compute super structure factors for all h,k,l,m for phase - no twins
1468    puts the result, F^2, in each ref[9] in refList
1469    works on blocks of 32 reflections for speed
1470    input:
1471   
1472    :param dict refDict: where
1473        'RefList' list where each ref = h,k,l,m,it,d,...
1474        'FF' dict of form factors - filed in below
1475    :param np.array G:      reciprocal metric tensor
1476    :param str pfx:    phase id string
1477    :param dict SGData: space group info. dictionary output from SpcGroup
1478    :param dict calcControls:
1479    :param dict ParmDict:
1480
1481    '''
1482    phfx = pfx.split(':')[0]+hfx
1483    ast = np.sqrt(np.diag(G))
1484    GS = G/np.outer(ast,ast)
1485    uAmat = G2lat.Gmat2AB(GS)[0]
1486    Mast = twopisq*np.multiply.outer(ast,ast)   
1487    SGInv = SGData['SGInv']
1488    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
1489    Ncen = len(SGData['SGCen'])
1490    Nops = len(SGMT)*Ncen*(1+SGData['SGInv'])
1491    SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
1492    SSGT = np.array([ops[1] for ops in SSGData['SSGOps']])
1493    SSCen = SSGData['SSGCen']
1494    FFtables = calcControls['FFtables']
1495    BLtables = calcControls['BLtables']
1496    MFtables = calcControls['MFtables']
1497    Amat,Bmat = G2lat.Gmat2AB(G)
1498    Flack = 1.0
1499    if not SGData['SGInv'] and 'S' in calcControls[hfx+'histType'] and phfx+'Flack' in parmDict:
1500        Flack = 1.-2.*parmDict[phfx+'Flack']
1501    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
1502        GetAtomFXU(pfx,calcControls,parmDict)
1503    if not Xdata.size:          #no atoms in phase!
1504        return
1505    waveTypes,FSSdata,XSSdata,USSdata,MSSdata = GetAtomSSFXU(pfx,calcControls,parmDict)
1506    ngl,nWaves,Fmod,Xmod,Umod,Mmod,glTau,glWt = G2mth.makeWaves(waveTypes,FSSdata,XSSdata,USSdata,MSSdata,Mast)      #NB: Mmod is ReIm,Mxyz,Ntau,Natm
1507    modQ = np.array([parmDict[pfx+'mV0'],parmDict[pfx+'mV1'],parmDict[pfx+'mV2']])
1508
1509    if parmDict[pfx+'isMag']:       #This part correct for making modulated mag moments on equiv atoms
1510       
1511        mXYZ = np.array([[xyz[0] for xyz in list(G2spc.GenAtom(xyz,SGData,All=True,Move=True))] for xyz in (Xdata+dXdata).T])%1. #Natn,Nop,xyz
1512        Tmag,TmagA,TmagB = G2mth.MagMod(ngl,mXYZ,modQ,MSSdata,SGData,SSGData)   #Ntau,Nops,Natm,Mxyz-Tmag matches drawing moments
1513       
1514        if not SGData['SGGray']:
1515            Mmod += Gdata.T[:,nxs,:]
1516            GSdata = np.inner(Gdata.T,np.swapaxes(SGMT,1,2))  #apply sym. ops.--> Natm,Nops,Nxyz
1517            if SGData['SGInv'] and not SGData['SGFixed']:   #inversion if any
1518                GSdata = np.hstack((GSdata,-GSdata))     
1519            GSdata = np.hstack([GSdata for cen in SSCen])        #dup over cell centering - Natm,Nops,Mxyz
1520            GSdata = SGData['MagMom'][nxs,:,nxs]*GSdata   #flip vectors according to spin flip * det(opM)
1521            GSdata = np.swapaxes(GSdata,0,1)    #Nop,Natm,Mxyz
1522            Tmag += Gdata.T[nxs,nxs,:,:]
1523           
1524        TmagC = np.inner(Tmag,uAmat.T)   #make cartesian; Ntau,Nops,Natm,,Mxyz
1525        Smag = np.sqrt(np.sum(TmagC**2,axis=-1))
1526        Kmag = TmagC/Smag[:,:,:,nxs]
1527
1528    FF = np.zeros(len(Tdata))
1529    if 'NC' in calcControls[hfx+'histType']:
1530        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
1531    elif 'X' in calcControls[hfx+'histType']:
1532        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
1533        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
1534    Uij = np.array(G2lat.U6toUij(Uijdata)).T
1535    bij = Mast*Uij
1536    blkSize = 48       #no. of reflections in a block
1537    nRef = refDict['RefList'].shape[0]
1538    SQ = 1./(2.*refDict['RefList'].T[5])**2
1539    if 'N' in calcControls[hfx+'histType']:
1540        dat = G2el.getBLvalues(BLtables)
1541        refDict['FF']['El'] = list(dat.keys())
1542        refDict['FF']['FF'] = np.ones((nRef,len(dat)))*list(dat.values())
1543        refDict['FF']['MF'] = np.zeros((nRef,len(dat)))
1544        for iel,El in enumerate(refDict['FF']['El']):
1545            if El in MFtables:
1546                refDict['FF']['MF'].T[iel] = G2el.MagScatFac(MFtables[El],SQ)
1547    else:
1548        dat = G2el.getFFvalues(FFtables,0.)
1549        refDict['FF']['El'] = list(dat.keys())
1550        refDict['FF']['FF'] = np.zeros((nRef,len(dat)))
1551        for iel,El in enumerate(refDict['FF']['El']):
1552            refDict['FF']['FF'].T[iel] = G2el.ScatFac(FFtables[El],SQ)
1553#    time0 = time.time()
1554#reflection processing begins here - big arrays!
1555    iBeg = 0
1556    while iBeg < nRef:
1557        iFin = min(iBeg+blkSize,nRef)
1558        mRef= iFin-iBeg
1559        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
1560        H = refl.T[:4]                          #array(blkSize,4)
1561        HP = H[:3]+modQ[:,nxs]*H[3:]            #projected hklm to hkl
1562        SQ = 1./(2.*refl.T[5])**2               #array(blkSize)
1563        SQfactor = 4.0*SQ*twopisq               #ditto prev.
1564        Uniq = np.inner(H.T,SSGMT)
1565        UniqP = np.inner(HP.T,SGMT)
1566        Phi = np.inner(H.T,SSGT)
1567        if SGInv and not SGData['SGFixed']:   #if centro - expand HKL sets
1568            Uniq = np.hstack((Uniq,-Uniq))
1569            Phi = np.hstack((Phi,-Phi))
1570            UniqP = np.hstack((UniqP,-UniqP))
1571        if 'T' in calcControls[hfx+'histType']:
1572            if 'P' in calcControls[hfx+'histType']:
1573                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[14])
1574            else:
1575                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[12])
1576            FP = np.repeat(FP.T,Uniq.shape[1],axis=0)
1577            FPP = np.repeat(FPP.T,Uniq.shape[1],axis=0)
1578        Bab = 0.
1579        if phfx+'BabA' in parmDict:
1580            Bab = np.repeat(parmDict[phfx+'BabA']*np.exp(-parmDict[phfx+'BabU']*SQfactor),Uniq.shape[1])
1581        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
1582        FF = np.repeat(refDict['FF']['FF'][iBeg:iFin].T[Tindx].T,Uniq.shape[1],axis=0)
1583        phase = twopi*(np.inner(Uniq[:,:,:3],(dXdata.T+Xdata.T))-Phi[:,:,nxs])
1584        phase = np.hstack([phase for cen in SSCen])
1585        sinp = np.sin(phase)
1586        cosp = np.cos(phase)
1587        biso = -SQfactor*Uisodata[:,nxs]
1588        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),Uniq.shape[1],axis=1).T
1589        HbH = -np.sum(UniqP[:,:,nxs,:]*np.inner(UniqP[:,:,:],bij),axis=-1)  #use hklt proj to hkl
1590        Tuij = np.where(HbH<1.,np.exp(HbH),1.0)
1591        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/Uniq.shape[1]  #refBlk x ops x atoms
1592
1593        if 'N' in calcControls[hfx+'histType'] and parmDict[pfx+'isMag']:       #TODO: mag math here??           
1594           
1595            phasem = twopi*np.inner(H.T[:,:3],mXYZ)
1596            phasem = np.swapaxes(phasem,1,2)
1597            cosm = np.cos(phasem)
1598            sinm = np.sin(phasem)
1599            MF = refDict['FF']['MF'][iBeg:iFin].T[Tindx].T   #Nref,Natm
1600            TMcorr = 0.539*(np.reshape(Tiso,Tuij.shape)*Tuij)[:,0,:]*Fdata*Mdata*MF/(Nops)     #Nref,Natm
1601#                     
1602            HM = np.inner(Bmat,HP.T)                            #put into cartesian space
1603            eM = HM/np.sqrt(np.sum(HM**2,axis=0))               #& normalize
1604#for modulated moments --> m != 0 reflections
1605            M = np.array(np.abs(H[3]),dtype=np.int)-1
1606            fam = TMcorr[:,nxs,nxs,:,nxs]*np.array([np.where(M[i]>=0,(TmagA*cosm[i,nxs,:,:,nxs]-np.sign(H[3])[i]*TmagB*sinm[i,nxs,:,:,nxs]),0.) for i in range(mRef)])
1607            fbm = TMcorr[:,nxs,nxs,:,nxs]*np.array([np.where(M[i]>=0,(TmagA*sinm[i,nxs,:,:,nxs]+np.sign(H[3])[i]*TmagB*cosm[i,nxs,:,:,nxs]),0.) for i in range(mRef)])
1608                       
1609            famq = np.sum(np.sum(fam/2.,axis=-2),axis=-2)      #Nref,Mxyz; sum ops & atoms
1610            fbmq = np.sum(np.sum(fbm/2.,axis=-2),axis=-2)
1611           
1612            fas = np.sum(famq,axis=-1)**2-np.sum(eM.T[:,nxs,:]*famq,axis=-1)**2      #mag intensity calc F^2-(e.F)^2
1613            fbs = np.sum(fbmq,axis=-1)**2-np.sum(eM.T[:,nxs,:]*fbmq,axis=-1)**2
1614           
1615            refl.T[10] = np.sum(fas*glWt,axis=1)+np.sum(fbs*glWt,axis=1)    #square of sums
1616            refl.T[11] = atan2d(fbs[:,0],fas[:,0])  #ignore f' & f"
1617
1618        else:
1619            GfpuA = G2mth.Modulation(Uniq,UniqP,nWaves,Fmod,Xmod,Umod,glTau,glWt) #2 x refBlk x sym X atoms
1620            if 'T' in calcControls[hfx+'histType']:
1621                fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-np.reshape(Flack*FPP,sinp.shape)*sinp*Tcorr])
1622                fb = np.array([np.reshape(Flack*FPP,cosp.shape)*cosp*Tcorr,np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr])
1623            else:
1624                fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-Flack*FPP*sinp*Tcorr])
1625                fb = np.array([Flack*FPP*cosp*Tcorr,np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr])
1626            fag = fa*GfpuA[0]-fb*GfpuA[1]   #real; 2 x refBlk x sym x atoms
1627            fbg = fb*GfpuA[0]+fa*GfpuA[1]
1628            fas = np.sum(np.sum(fag,axis=-1),axis=-1)   #2 x refBlk; sum sym & atoms
1629            fbs = np.sum(np.sum(fbg,axis=-1),axis=-1)
1630           
1631            refl.T[10] = np.sum(fas,axis=0)**2+np.sum(fbs,axis=0)**2    #square of sums
1632            refl.T[11] = atan2d(fbs[0],fas[0])  #ignore f' & f"
1633        if 'P' not in calcControls[hfx+'histType']:
1634            refl.T[8] = np.copy(refl.T[10])               
1635        iBeg += blkSize
1636#    print ('nRef %d time %.4f\r'%(nRef,time.time()-time0))
1637    return copy.deepcopy(refDict['RefList'])
1638
1639def SStructureFactorTw(refDict,G,hfx,pfx,SGData,SSGData,calcControls,parmDict):
1640    '''
1641    Compute super structure factors for all h,k,l,m for phase - twins only
1642    puts the result, F^2, in each ref[8+im] in refList
1643    works on blocks of 32 reflections for speed
1644    input:
1645   
1646    :param dict refDict: where
1647        'RefList' list where each ref = h,k,l,m,it,d,...
1648        'FF' dict of form factors - filed in below
1649    :param np.array G:      reciprocal metric tensor
1650    :param str pfx:    phase id string
1651    :param dict SGData: space group info. dictionary output from SpcGroup
1652    :param dict calcControls:
1653    :param dict ParmDict:
1654
1655    '''
1656    phfx = pfx.split(':')[0]+hfx
1657    ast = np.sqrt(np.diag(G))
1658    Mast = twopisq*np.multiply.outer(ast,ast)   
1659    SGInv = SGData['SGInv']
1660    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
1661    SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
1662    SSGT = np.array([ops[1] for ops in SSGData['SSGOps']])
1663    FFtables = calcControls['FFtables']
1664    BLtables = calcControls['BLtables']
1665    MFtables = calcControls['MFtables']
1666    Flack = 1.0
1667    if not SGData['SGInv'] and 'S' in calcControls[hfx+'histType'] and phfx+'Flack' in parmDict:
1668        Flack = 1.-2.*parmDict[phfx+'Flack']
1669    TwinLaw = np.array([[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],])    #4D?
1670    TwDict = refDict.get('TwDict',{})           
1671    if 'S' in calcControls[hfx+'histType']:
1672        NTL = calcControls[phfx+'NTL']
1673        NM = calcControls[phfx+'TwinNMN']+1
1674        TwinLaw = calcControls[phfx+'TwinLaw']  #this'll have to be 4D also...
1675        TwinFr = np.array([parmDict[phfx+'TwinFr:'+str(i)] for i in range(len(TwinLaw))])
1676        TwinInv = list(np.where(calcControls[phfx+'TwinInv'],-1,1))
1677    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
1678        GetAtomFXU(pfx,calcControls,parmDict)
1679    if not Xdata.size:          #no atoms in phase!
1680        return
1681    waveTypes,FSSdata,XSSdata,USSdata,MSSdata = GetAtomSSFXU(pfx,calcControls,parmDict)
1682    ngl,nWaves,Fmod,Xmod,Umod,Mmod,glTau,glWt = G2mth.makeWaves(waveTypes,FSSdata,XSSdata,USSdata,Mast)
1683    modQ = np.array([parmDict[pfx+'mV0'],parmDict[pfx+'mV1'],parmDict[pfx+'mV2']])
1684    FF = np.zeros(len(Tdata))
1685    if 'NC' in calcControls[hfx+'histType']:
1686        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
1687    elif 'X' in calcControls[hfx+'histType']:
1688        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
1689        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
1690    Uij = np.array(G2lat.U6toUij(Uijdata)).T
1691    bij = Mast*Uij
1692    blkSize = 32       #no. of reflections in a block
1693    nRef = refDict['RefList'].shape[0]
1694    if not len(refDict['FF']):                #no form factors - 1st time thru StructureFactor
1695        SQ = 1./(2.*refDict['RefList'].T[5])**2
1696        if 'N' in calcControls[hfx+'histType']:
1697            dat = G2el.getBLvalues(BLtables)
1698            refDict['FF']['El'] = list(dat.keys())
1699            refDict['FF']['FF'] = np.ones((nRef,len(dat)))*list(dat.values())
1700            refDict['FF']['MF'] = np.zeros((nRef,len(dat)))
1701            for iel,El in enumerate(refDict['FF']['El']):
1702                if El in MFtables:
1703                    refDict['FF']['MF'].T[iel] = G2el.MagScatFac(MFtables[El],SQ)
1704        else:
1705            dat = G2el.getFFvalues(FFtables,0.)
1706            refDict['FF']['El'] = list(dat.keys())
1707            refDict['FF']['FF'] = np.zeros((nRef,len(dat)))
1708            for iel,El in enumerate(refDict['FF']['El']):
1709                refDict['FF']['FF'].T[iel] = G2el.ScatFac(FFtables[El],SQ)
1710#    time0 = time.time()
1711#reflection processing begins here - big arrays!
1712    iBeg = 0
1713    while iBeg < nRef:
1714        iFin = min(iBeg+blkSize,nRef)
1715        refl = refDict['RefList'][iBeg:iFin]    #array(blkSize,nItems)
1716        H = refl[:,:4]                          #array(blkSize,4)
1717        H3 = refl[:,:3]
1718        HP = H[:,:3]+modQ[nxs,:]*H[:,3:]        #projected hklm to hkl
1719        HP = np.inner(HP,TwinLaw)             #array(blkSize,nTwins,4)
1720        H3 = np.inner(H3,TwinLaw)       
1721        TwMask = np.any(HP,axis=-1)
1722        if TwinLaw.shape[0] > 1 and TwDict: #need np.inner(TwinLaw[?],TwDict[iref][i])*TwinInv[i]
1723            for ir in range(blkSize):
1724                iref = ir+iBeg
1725                if iref in TwDict:
1726                    for i in TwDict[iref]:
1727                        for n in range(NTL):
1728                            HP[ir][i+n*NM] = np.inner(TwinLaw[n*NM],np.array(TwDict[iref][i])*TwinInv[i+n*NM])
1729                            H3[ir][i+n*NM] = np.inner(TwinLaw[n*NM],np.array(TwDict[iref][i])*TwinInv[i+n*NM])
1730            TwMask = np.any(HP,axis=-1)
1731        SQ = 1./(2.*refl.T[5])**2               #array(blkSize)
1732        SQfactor = 4.0*SQ*twopisq               #ditto prev.
1733        Uniq = np.inner(H,SSGMT)
1734        Uniq3 = np.inner(H3,SGMT)
1735        UniqP = np.inner(HP,SGMT)
1736        Phi = np.inner(H,SSGT)
1737        if SGInv:   #if centro - expand HKL sets
1738            Uniq = np.hstack((Uniq,-Uniq))
1739            Uniq3 = np.hstack((Uniq3,-Uniq3))
1740            Phi = np.hstack((Phi,-Phi))
1741            UniqP = np.hstack((UniqP,-UniqP))
1742        if 'T' in calcControls[hfx+'histType']:
1743            if 'P' in calcControls[hfx+'histType']:
1744                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[14])
1745            else:
1746                FP,FPP = G2el.BlenResTOF(Tdata,BLtables,refl.T[12])
1747            FP = np.repeat(FP.T,Uniq.shape[1]*len(TwinLaw),axis=0)
1748            FPP = np.repeat(FPP.T,Uniq.shape[1]*len(TwinLaw),axis=0)
1749        Bab = np.repeat(parmDict[phfx+'BabA']*np.exp(-parmDict[phfx+'BabU']*SQfactor),Uniq.shape[1]*len(TwinLaw))
1750        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
1751        FF = np.repeat(refDict['FF']['FF'][iBeg:iFin].T[Tindx].T,Uniq.shape[1]*len(TwinLaw),axis=0)
1752        phase = twopi*(np.inner(Uniq3,(dXdata.T+Xdata.T))-Phi[:,nxs,:,nxs])
1753        sinp = np.sin(phase)
1754        cosp = np.cos(phase)
1755        biso = -SQfactor*Uisodata[:,nxs]
1756        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),Uniq.shape[1]*len(TwinLaw),axis=1).T
1757        HbH = -np.sum(UniqP[:,:,:,nxs]*np.inner(UniqP[:,:,:],bij),axis=-1)  #use hklt proj to hkl
1758        Tuij = np.where(HbH<1.,np.exp(HbH),1.0)
1759        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/Uniq.shape[1]  #refBlk x ops x atoms
1760        if 'T' in calcControls[hfx+'histType']:
1761            fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-np.reshape(Flack*FPP,sinp.shape)*sinp*Tcorr])
1762            fb = np.array([np.reshape(Flack*FPP,cosp.shape)*cosp*Tcorr,np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr])
1763        else:
1764            fa = np.array([np.reshape(((FF+FP).T-Bab).T,cosp.shape)*cosp*Tcorr,-Flack*FPP*sinp*Tcorr])
1765            fb = np.array([Flack*FPP*cosp*Tcorr,np.reshape(((FF+FP).T-Bab).T,sinp.shape)*sinp*Tcorr])
1766        GfpuA = G2mth.ModulationTw(Uniq,UniqP,nWaves,Fmod,Xmod,Umod,glTau,glWt) #2 x refBlk x sym X atoms
1767        fag = fa*GfpuA[0]-fb*GfpuA[1]   #real; 2 x refBlk x sym x atoms
1768        fbg = fb*GfpuA[0]+fa*GfpuA[1]
1769        fas = np.sum(np.sum(fag,axis=-1),axis=-1)   #2 x refBlk; sum sym & atoms
1770        fbs = np.sum(np.sum(fbg,axis=-1),axis=-1)
1771        refl.T[10] = np.sum(fas[:,:,0],axis=0)**2+np.sum(fbs[:,:,0],axis=0)**2                  #FcT from primary twin element
1772        refl.T[8] = np.sum(TwinFr*np.sum(TwMask[nxs,:,:]*fas,axis=0)**2,axis=-1)+   \
1773            np.sum(TwinFr*np.sum(TwMask[nxs,:,:]*fbs,axis=0)**2,axis=-1)                 #Fc sum over twins
1774        refl.T[11] = atan2d(fbs[0].T[0],fas[0].T[0])  #ignore f' & f"
1775        iBeg += blkSize
1776#    print ('nRef %d time %.4f\r'%(nRef,time.time()-time0))
1777
1778def SStructureFactorDerv(refDict,im,G,hfx,pfx,SGData,SSGData,calcControls,parmDict):
1779    '''
1780    Compute super structure factor derivatives for all h,k,l,m for phase - no twins
1781    Only Fourier component are done analytically here
1782    input:
1783   
1784    :param dict refDict: where
1785        'RefList' list where each ref = h,k,l,m,it,d,...
1786        'FF' dict of form factors - filled in below
1787    :param int im: = 1 (could be eliminated)
1788    :param np.array G:      reciprocal metric tensor
1789    :param str hfx:    histogram id string
1790    :param str pfx:    phase id string
1791    :param dict SGData: space group info. dictionary output from SpcGroup
1792    :param dict SSGData: super space group info.
1793    :param dict calcControls:
1794    :param dict ParmDict:
1795   
1796    :returns: dict dFdvDict: dictionary of derivatives
1797    '''
1798    phfx = pfx.split(':')[0]+hfx
1799    ast = np.sqrt(np.diag(G))
1800    Mast = twopisq*np.multiply.outer(ast,ast)
1801    SGInv = SGData['SGInv']
1802    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
1803    SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
1804    SSGT = np.array([ops[1] for ops in SSGData['SSGOps']])
1805    FFtables = calcControls['FFtables']
1806    BLtables = calcControls['BLtables']
1807    nRef = len(refDict['RefList'])
1808    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
1809        GetAtomFXU(pfx,calcControls,parmDict)
1810    if not Xdata.size:          #no atoms in phase!
1811        return {}
1812    mSize = len(Mdata)  #no. atoms
1813    waveTypes,FSSdata,XSSdata,USSdata,MSSdata = GetAtomSSFXU(pfx,calcControls,parmDict)
1814    ngl,nWaves,Fmod,Xmod,Umod,Mmod,glTau,glWt = G2mth.makeWaves(waveTypes,FSSdata,XSSdata,USSdata,MSSdata,Mast)
1815    waveShapes,SCtauF,SCtauX,SCtauU,UmodAB = G2mth.makeWavesDerv(ngl,waveTypes,FSSdata,XSSdata,USSdata,Mast)
1816    modQ = np.array([parmDict[pfx+'mV0'],parmDict[pfx+'mV1'],parmDict[pfx+'mV2']])
1817    FF = np.zeros(len(Tdata))
1818    if 'NC' in calcControls[hfx+'histType']:
1819        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
1820    elif 'X' in calcControls[hfx+'histType']:
1821        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
1822        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
1823    Uij = np.array(G2lat.U6toUij(Uijdata)).T
1824    bij = Mast*Uij
1825    if not len(refDict['FF']):
1826        if 'N' in calcControls[hfx+'histType']:
1827            dat = G2el.getBLvalues(BLtables)        #will need wave here for anom. neutron b's
1828        else:
1829            dat = G2el.getFFvalues(FFtables,0.)       
1830        refDict['FF']['El'] = list(dat.keys())
1831        refDict['FF']['FF'] = np.zeros((len(refDict['RefList']),len(dat)))
1832    dFdvDict = {}
1833    dFdfr = np.zeros((nRef,mSize))
1834    dFdx = np.zeros((nRef,mSize,3))
1835    dFdui = np.zeros((nRef,mSize))
1836    dFdua = np.zeros((nRef,mSize,6))
1837    dFdbab = np.zeros((nRef,2))
1838    dFdfl = np.zeros((nRef))
1839    dFdGf = np.zeros((nRef,mSize,FSSdata.shape[1],2))
1840    dFdGx = np.zeros((nRef,mSize,XSSdata.shape[1],6))
1841    dFdGu = np.zeros((nRef,mSize,USSdata.shape[1],12))
1842    Flack = 1.0
1843    if not SGData['SGInv'] and 'S' in calcControls[hfx+'histType'] and phfx+'Flack' in parmDict:
1844        Flack = 1.-2.*parmDict[phfx+'Flack']
1845    time0 = time.time()
1846    nRef = len(refDict['RefList'])/100
1847    for iref,refl in enumerate(refDict['RefList']):
1848        if 'T' in calcControls[hfx+'histType']:
1849            FP,FPP = G2el.BlenResCW(Tdata,BLtables,refl.T[12+im])
1850        H = np.array(refl[:4])
1851        HP = H[:3]+modQ*H[3:]            #projected hklm to hkl
1852        SQ = 1./(2.*refl[4+im])**2             # or (sin(theta)/lambda)**2
1853        SQfactor = 8.0*SQ*np.pi**2
1854        Bab = 0.0
1855        if phfx+'BabA' in parmDict:
1856            dBabdA = np.exp(-parmDict[phfx+'BabU']*SQfactor)
1857            Bab = parmDict[phfx+'BabA']*dBabdA
1858        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
1859        FF = refDict['FF']['FF'][iref].T[Tindx]
1860        Uniq = np.inner(H,SSGMT)
1861        Phi = np.inner(H,SSGT)
1862        UniqP = np.inner(HP,SGMT)
1863        if SGInv:   #if centro - expand HKL sets
1864            Uniq = np.vstack((Uniq,-Uniq))
1865            Phi = np.hstack((Phi,-Phi))
1866            UniqP = np.vstack((UniqP,-UniqP))
1867        phase = twopi*(np.inner(Uniq[:,:3],(dXdata+Xdata).T)+Phi[:,nxs])
1868        sinp = np.sin(phase)
1869        cosp = np.cos(phase)
1870        occ = Mdata*Fdata/Uniq.shape[0]
1871        biso = -SQfactor*Uisodata[:,nxs]
1872        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),Uniq.shape[0],axis=1).T    #ops x atoms
1873        HbH = -np.sum(UniqP[:,nxs,:3]*np.inner(UniqP[:,:3],bij),axis=-1)  #ops x atoms
1874        Hij = np.array([Mast*np.multiply.outer(U[:3],U[:3]) for U in UniqP]) #atoms x 3x3
1875        Hij = np.array([G2lat.UijtoU6(uij) for uij in Hij])                     #atoms x 6
1876        Tuij = np.where(HbH<1.,np.exp(HbH),1.0)     #ops x atoms
1877        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/Uniq.shape[0]  #ops x atoms
1878        fot = (FF+FP-Bab)*Tcorr     #ops x atoms
1879        fotp = FPP*Tcorr            #ops x atoms
1880        GfpuA = G2mth.Modulation(Uniq,UniqP,nWaves,Fmod,Xmod,Umod,glTau,glWt) #2 x sym X atoms
1881        dGdf,dGdx,dGdu = G2mth.ModulationDerv(Uniq,UniqP,Hij,nWaves,waveShapes,Fmod,Xmod,UmodAB,SCtauF,SCtauX,SCtauU,glTau,glWt)
1882        # GfpuA is 2 x ops x atoms
1883        # derivs are: ops x atoms x waves x 2,6,12, or 5 parms as [real,imag] parts
1884        fa = np.array([((FF+FP).T-Bab).T*cosp*Tcorr,-Flack*FPP*sinp*Tcorr]) # array(2,nEqv,nAtoms)
1885        fb = np.array([((FF+FP).T-Bab).T*sinp*Tcorr,Flack*FPP*cosp*Tcorr])  #or array(2,nEqv,nAtoms)
1886        fag = fa*GfpuA[0]-fb*GfpuA[1]
1887        fbg = fb*GfpuA[0]+fa*GfpuA[1]
1888       
1889        fas = np.sum(np.sum(fag,axis=1),axis=1)     # 2 x twin
1890        fbs = np.sum(np.sum(fbg,axis=1),axis=1)
1891        fax = np.array([-fot*sinp,-fotp*cosp])   #positions; 2 x ops x atoms
1892        fbx = np.array([fot*cosp,-fotp*sinp])
1893        fax = fax*GfpuA[0]-fbx*GfpuA[1]
1894        fbx = fbx*GfpuA[0]+fax*GfpuA[1]
1895        #sum below is over Uniq
1896        dfadfr = np.sum(fag/occ,axis=1)        #Fdata != 0 ever avoids /0. problem
1897        dfbdfr = np.sum(fbg/occ,axis=1)        #Fdata != 0 avoids /0. problem
1898        dfadba = np.sum(-cosp*Tcorr[:,nxs],axis=1)
1899        dfbdba = np.sum(-sinp*Tcorr[:,nxs],axis=1)
1900        dfadui = np.sum(-SQfactor*fag,axis=1)
1901        dfbdui = np.sum(-SQfactor*fbg,axis=1)
1902        dfadx = np.sum(twopi*Uniq[:,:3]*np.swapaxes(fax,-2,-1)[:,:,:,nxs],axis=-2)  #2 x nAtom x 3xyz; sum nOps
1903        dfbdx = np.sum(twopi*Uniq[:,:3]*np.swapaxes(fbx,-2,-1)[:,:,:,nxs],axis=-2)           
1904        dfadua = np.sum(-Hij*np.swapaxes(fag,-2,-1)[:,:,:,nxs],axis=-2)             #2 x nAtom x 6Uij; sum nOps
1905        dfbdua = np.sum(-Hij*np.swapaxes(fbg,-2,-1)[:,:,:,nxs],axis=-2)         #these are correct also for twins above
1906        # array(2,nAtom,nWave,2) & array(2,nAtom,nWave,6) & array(2,nAtom,nWave,12); sum on nOps
1907        dfadGf = np.sum(fa[:,:,:,nxs,nxs]*dGdf[0][nxs,:,:,:,:]-fb[:,:,:,nxs,nxs]*dGdf[1][nxs,:,:,:,:],axis=1)
1908        dfbdGf = np.sum(fb[:,:,:,nxs,nxs]*dGdf[0][nxs,:,:,:,:]+fa[:,:,:,nxs,nxs]*dGdf[1][nxs,:,:,:,:],axis=1)
1909        dfadGx = np.sum(fa[:,:,:,nxs,nxs]*dGdx[0][nxs,:,:,:,:]-fb[:,:,:,nxs,nxs]*dGdx[1][nxs,:,:,:,:],axis=1)
1910        dfbdGx = np.sum(fb[:,:,:,nxs,nxs]*dGdx[0][nxs,:,:,:,:]+fa[:,:,:,nxs,nxs]*dGdx[1][nxs,:,:,:,:],axis=1)
1911        dfadGu = np.sum(fa[:,:,:,nxs,nxs]*dGdu[0][nxs,:,:,:,:]-fb[:,:,:,nxs,nxs]*dGdu[1][nxs,:,:,:,:],axis=1)
1912        dfbdGu = np.sum(fb[:,:,:,nxs,nxs]*dGdu[0][nxs,:,:,:,:]+fa[:,:,:,nxs,nxs]*dGdu[1][nxs,:,:,:,:],axis=1)   
1913        if not SGData['SGInv']:   #Flack derivative
1914            dfadfl = np.sum(-FPP*Tcorr*sinp)
1915            dfbdfl = np.sum(FPP*Tcorr*cosp)
1916        else:
1917            dfadfl = 1.0
1918            dfbdfl = 1.0
1919        SA = fas[0]+fas[1]      #float = A+A'
1920        SB = fbs[0]+fbs[1]      #float = B+B'
1921        if 'P' in calcControls[hfx+'histType']: #checked perfect for centro & noncentro?
1922            dFdfl[iref] = -SA*dfadfl-SB*dfbdfl                  #array(nRef,)
1923            dFdfr[iref] = 2.*(fas[0]*dfadfr[0]+fas[1]*dfadfr[1])*Mdata/len(Uniq)+   \
1924                2.*(fbs[0]*dfbdfr[0]-fbs[1]*dfbdfr[1])*Mdata/len(Uniq)
1925            dFdx[iref] = 2.*(fas[0]*dfadx[0]+fas[1]*dfadx[1])+  \
1926                2.*(fbs[0]*dfbdx[0]+fbs[1]*dfbdx[1])
1927            dFdui[iref] = 2.*(fas[0]*dfadui[0]+fas[1]*dfadui[1])+   \
1928                2.*(fbs[0]*dfbdui[0]-fbs[1]*dfbdui[1])
1929            dFdua[iref] = 2.*(fas[0]*dfadua[0]+fas[1]*dfadua[1])+   \
1930                2.*(fbs[0]*dfbdua[0]+fbs[1]*dfbdua[1])
1931            dFdGf[iref] = 2.*(fas[0]*dfadGf[0]+fas[1]*dfadGf[1])+  \
1932                2.*(fbs[0]*dfbdGf[0]+fbs[1]*dfbdGf[1])
1933            dFdGx[iref] = 2.*(fas[0]*dfadGx[0]+fas[1]*dfadGx[1])+  \
1934                2.*(fbs[0]*dfbdGx[0]-fbs[1]*dfbdGx[1])
1935            dFdGu[iref] = 2.*(fas[0]*dfadGu[0]+fas[1]*dfadGu[1])+  \
1936                2.*(fbs[0]*dfbdGu[0]+fbs[1]*dfbdGu[1])
1937        else:                       #OK, I think
1938            dFdfr[iref] = 2.*(SA*dfadfr[0]+SA*dfadfr[1]+SB*dfbdfr[0]+SB*dfbdfr[1])*Mdata/len(Uniq) #array(nRef,nAtom)
1939            dFdx[iref] = 2.*(SA*dfadx[0]+SA*dfadx[1]+SB*dfbdx[0]+SB*dfbdx[1])    #array(nRef,nAtom,3)
1940            dFdui[iref] = 2.*(SA*dfadui[0]+SA*dfadui[1]+SB*dfbdui[0]+SB*dfbdui[1])   #array(nRef,nAtom)
1941            dFdua[iref] = 2.*(SA*dfadua[0]+SA*dfadua[1]+SB*dfbdua[0]+SB*dfbdua[1])    #array(nRef,nAtom,6)
1942            dFdfl[iref] = -SA*dfadfl-SB*dfbdfl                  #array(nRef,)
1943                           
1944            dFdGf[iref] = 2.*(SA*dfadGf[0]+SB*dfbdGf[1])      #array(nRef,natom,nwave,2)
1945            dFdGx[iref] = 2.*(SA*dfadGx[0]+SB*dfbdGx[1])      #array(nRef,natom,nwave,6)
1946            dFdGu[iref] = 2.*(SA*dfadGu[0]+SB*dfbdGu[1])      #array(nRef,natom,nwave,12)
1947        if phfx+'BabA' in parmDict:
1948            dFdbab[iref] = 2.*fas[0]*np.array([np.sum(dfadba*dBabdA),np.sum(-dfadba*parmDict[phfx+'BabA']*SQfactor*dBabdA)]).T+ \
1949                2.*fbs[0]*np.array([np.sum(dfbdba*dBabdA),np.sum(-dfbdba*parmDict[phfx+'BabA']*SQfactor*dBabdA)]).T
1950        #loop over atoms - each dict entry is list of derivatives for all the reflections
1951        if not iref%100 :
1952            print (' %d derivative time %.4f\r'%(iref,time.time()-time0),end='')
1953    for i in range(len(Mdata)):     #loop over atoms
1954        dFdvDict[pfx+'Afrac:'+str(i)] = dFdfr.T[i]
1955        dFdvDict[pfx+'dAx:'+str(i)] = dFdx.T[0][i]
1956        dFdvDict[pfx+'dAy:'+str(i)] = dFdx.T[1][i]
1957        dFdvDict[pfx+'dAz:'+str(i)] = dFdx.T[2][i]
1958        dFdvDict[pfx+'AUiso:'+str(i)] = dFdui.T[i]
1959        dFdvDict[pfx+'AU11:'+str(i)] = dFdua.T[0][i]
1960        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
1961        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
1962        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
1963        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
1964        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
1965        for j in range(FSSdata.shape[1]):        #loop over waves Fzero & Fwid?
1966            dFdvDict[pfx+'Fsin:'+str(i)+':'+str(j)] = dFdGf.T[0][j][i]
1967            dFdvDict[pfx+'Fcos:'+str(i)+':'+str(j)] = dFdGf.T[1][j][i]
1968        nx = 0
1969        if waveTypes[i] in ['Block','ZigZag']:
1970            nx = 1 
1971        for j in range(XSSdata.shape[1]-nx):       #loop over waves
1972            dFdvDict[pfx+'Xsin:'+str(i)+':'+str(j+nx)] = dFdGx.T[0][j][i]
1973            dFdvDict[pfx+'Ysin:'+str(i)+':'+str(j+nx)] = dFdGx.T[1][j][i]
1974            dFdvDict[pfx+'Zsin:'+str(i)+':'+str(j+nx)] = dFdGx.T[2][j][i]
1975            dFdvDict[pfx+'Xcos:'+str(i)+':'+str(j+nx)] = dFdGx.T[3][j][i]
1976            dFdvDict[pfx+'Ycos:'+str(i)+':'+str(j+nx)] = dFdGx.T[4][j][i]
1977            dFdvDict[pfx+'Zcos:'+str(i)+':'+str(j+nx)] = dFdGx.T[5][j][i]
1978        for j in range(USSdata.shape[1]):       #loop over waves
1979            dFdvDict[pfx+'U11sin:'+str(i)+':'+str(j)] = dFdGu.T[0][j][i]
1980            dFdvDict[pfx+'U22sin:'+str(i)+':'+str(j)] = dFdGu.T[1][j][i]
1981            dFdvDict[pfx+'U33sin:'+str(i)+':'+str(j)] = dFdGu.T[2][j][i]
1982            dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[3][j][i]
1983            dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[4][j][i]
1984            dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[5][j][i]
1985            dFdvDict[pfx+'U11cos:'+str(i)+':'+str(j)] = dFdGu.T[6][j][i]
1986            dFdvDict[pfx+'U22cos:'+str(i)+':'+str(j)] = dFdGu.T[7][j][i]
1987            dFdvDict[pfx+'U33cos:'+str(i)+':'+str(j)] = dFdGu.T[8][j][i]
1988            dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[9][j][i]
1989            dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[10][j][i]
1990            dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[11][j][i]
1991           
1992    dFdvDict[phfx+'Flack'] = 4.*dFdfl.T
1993    dFdvDict[phfx+'BabA'] = dFdbab.T[0]
1994    dFdvDict[phfx+'BabU'] = dFdbab.T[1]
1995    return dFdvDict
1996
1997def SStructureFactorDerv2(refDict,im,G,hfx,pfx,SGData,SSGData,calcControls,parmDict):
1998    '''
1999    Compute super structure factor derivatives for all h,k,l,m for phase - no twins
2000    input:
2001   
2002    :param dict refDict: where
2003        'RefList' list where each ref = h,k,l,m,it,d,...
2004        'FF' dict of form factors - filled in below
2005    :param int im: = 1 (could be eliminated)
2006    :param np.array G:      reciprocal metric tensor
2007    :param str hfx:    histogram id string
2008    :param str pfx:    phase id string
2009    :param dict SGData: space group info. dictionary output from SpcGroup
2010    :param dict SSGData: super space group info.
2011    :param dict calcControls:
2012    :param dict ParmDict:
2013   
2014    :returns: dict dFdvDict: dictionary of derivatives
2015    '''
2016
2017    trefDict = copy.deepcopy(refDict)
2018    dM = 1.e-4
2019    dFdvDict = {}
2020    for parm in parmDict:
2021        if parm == '0':
2022            continue
2023        if parm.split(':')[2] in ['Tmin','Tmax','Xmax','Ymax','Zmax','Fzero','Fwid',
2024            'MXsin','MXcos','MYsin','MYcos','MZsin','MZcos','AMx','AMy','AMz',]:
2025            parmDict[parm] += dM
2026            prefList = SStructureFactor(trefDict,G,hfx,pfx,SGData,SSGData,calcControls,parmDict)
2027            parmDict[parm] -= 2*dM
2028            mrefList = SStructureFactor(trefDict,G,hfx,pfx,SGData,SSGData,calcControls,parmDict)
2029            parmDict[parm] += dM
2030            dFdvDict[parm] = (prefList[:,9+im]-mrefList[:,9+im])/(2.*dM)
2031    return dFdvDict
2032   
2033def SStructureFactorDervTw(refDict,im,G,hfx,pfx,SGData,SSGData,calcControls,parmDict):
2034    'Needs a doc string'
2035    phfx = pfx.split(':')[0]+hfx
2036    ast = np.sqrt(np.diag(G))
2037    Mast = twopisq*np.multiply.outer(ast,ast)
2038    SGInv = SGData['SGInv']
2039    SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
2040    SSGMT = np.array([ops[0].T for ops in SSGData['SSGOps']])
2041    SSGT = np.array([ops[1] for ops in SSGData['SSGOps']])
2042    FFtables = calcControls['FFtables']
2043    BLtables = calcControls['BLtables']
2044    TwinLaw = np.array([[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],])
2045    TwDict = refDict.get('TwDict',{})           
2046    if 'S' in calcControls[hfx+'histType']:
2047        NTL = calcControls[phfx+'NTL']
2048        NM = calcControls[phfx+'TwinNMN']+1
2049        TwinLaw = calcControls[phfx+'TwinLaw']
2050        TwinInv = list(np.where(calcControls[phfx+'TwinInv'],-1,1))
2051    nTwin = len(TwinLaw)       
2052    nRef = len(refDict['RefList'])
2053    Tdata,Mdata,Fdata,Xdata,dXdata,IAdata,Uisodata,Uijdata,Gdata = \
2054        GetAtomFXU(pfx,calcControls,parmDict)
2055    if not Xdata.size:          #no atoms in phase!
2056        return {}
2057    mSize = len(Mdata)  #no. atoms
2058    waveTypes,FSSdata,XSSdata,USSdata,MSSdata = GetAtomSSFXU(pfx,calcControls,parmDict)
2059    ngl,nWaves,Fmod,Xmod,Umod,Mmod,glTau,glWt = G2mth.makeWaves(waveTypes,FSSdata,XSSdata,USSdata,MSSdata,Mast)     #NB: Mmod is ReIm,Mxyz,Ntau,Natm
2060    waveShapes,SCtauF,SCtauX,SCtauU,UmodAB = G2mth.makeWavesDerv(ngl,waveTypes,FSSdata,XSSdata,USSdata,Mast)
2061    modQ = np.array([parmDict[pfx+'mV0'],parmDict[pfx+'mV1'],parmDict[pfx+'mV2']])
2062    FF = np.zeros(len(Tdata))
2063    if 'NC' in calcControls[hfx+'histType']:
2064        FP,FPP = G2el.BlenResCW(Tdata,BLtables,parmDict[hfx+'Lam'])
2065    elif 'X' in calcControls[hfx+'histType']:
2066        FP = np.array([FFtables[El][hfx+'FP'] for El in Tdata])
2067        FPP = np.array([FFtables[El][hfx+'FPP'] for El in Tdata])
2068    Uij = np.array(G2lat.U6toUij(Uijdata)).T
2069    bij = Mast*Uij
2070    if not len(refDict['FF']):
2071        if 'N' in calcControls[hfx+'histType']:
2072            dat = G2el.getBLvalues(BLtables)        #will need wave here for anom. neutron b's
2073        else:
2074            dat = G2el.getFFvalues(FFtables,0.)       
2075        refDict['FF']['El'] = list(dat.keys())
2076        refDict['FF']['FF'] = np.zeros((len(refDict['RefList']),len(dat)))
2077    dFdvDict = {}
2078    dFdfr = np.zeros((nRef,nTwin,mSize))
2079    dFdx = np.zeros((nRef,nTwin,mSize,3))
2080    dFdui = np.zeros((nRef,nTwin,mSize))
2081    dFdua = np.zeros((nRef,nTwin,mSize,6))
2082    dFdbab = np.zeros((nRef,nTwin,2))
2083    dFdtw = np.zeros((nRef,nTwin))
2084    dFdGf = np.zeros((nRef,nTwin,mSize,FSSdata.shape[1]))
2085    dFdGx = np.zeros((nRef,nTwin,mSize,XSSdata.shape[1],3))
2086    dFdGz = np.zeros((nRef,nTwin,mSize,5))
2087    dFdGu = np.zeros((nRef,nTwin,mSize,USSdata.shape[1],6))
2088    Flack = 1.0
2089    if not SGData['SGInv'] and 'S' in calcControls[hfx+'histType'] and phfx+'Flack' in parmDict:
2090        Flack = 1.-2.*parmDict[phfx+'Flack']
2091    time0 = time.time()
2092    nRef = len(refDict['RefList'])/100
2093    for iref,refl in enumerate(refDict['RefList']):
2094        if 'T' in calcControls[hfx+'histType']:
2095            FP,FPP = G2el.BlenResCW(Tdata,BLtables,refl.T[12+im])
2096        H = np.array(refl[:4])
2097        HP = H[:3]+modQ*H[3:]            #projected hklm to hkl
2098        H = np.inner(H.T,TwinLaw)   #maybe array(4,nTwins) or (4)
2099        TwMask = np.any(H,axis=-1)
2100        if TwinLaw.shape[0] > 1 and TwDict:
2101            if iref in TwDict:
2102                for i in TwDict[iref]:
2103                    for n in range(NTL):
2104                        H[i+n*NM] = np.inner(TwinLaw[n*NM],np.array(TwDict[iref][i])*TwinInv[i+n*NM])
2105            TwMask = np.any(H,axis=-1)
2106        SQ = 1./(2.*refl[4+im])**2             # or (sin(theta)/lambda)**2
2107        SQfactor = 8.0*SQ*np.pi**2
2108        dBabdA = np.exp(-parmDict[phfx+'BabU']*SQfactor)
2109        Bab = parmDict[phfx+'BabA']*dBabdA
2110        Tindx = np.array([refDict['FF']['El'].index(El) for El in Tdata])
2111        FF = refDict['FF']['FF'][iref].T[Tindx]
2112        Uniq = np.inner(H,SSGMT)
2113        Phi = np.inner(H,SSGT)
2114        UniqP = np.inner(HP,SGMT)
2115        if SGInv:   #if centro - expand HKL sets
2116            Uniq = np.vstack((Uniq,-Uniq))
2117            Phi = np.hstack((Phi,-Phi))
2118            UniqP = np.vstack((UniqP,-UniqP))
2119        phase = twopi*(np.inner(Uniq[:,:3],(dXdata+Xdata).T)+Phi[:,nxs])
2120        sinp = np.sin(phase)
2121        cosp = np.cos(phase)
2122        occ = Mdata*Fdata/Uniq.shape[0]
2123        biso = -SQfactor*Uisodata[:,nxs]
2124        Tiso = np.repeat(np.where(biso<1.,np.exp(biso),1.0),Uniq.shape[0]*len(TwinLaw),axis=1).T    #ops x atoms
2125        HbH = -np.sum(UniqP[:,nxs,:3]*np.inner(UniqP[:,:3],bij),axis=-1)  #ops x atoms
2126        Hij = np.array([Mast*np.multiply.outer(U[:3],U[:3]) for U in UniqP]) #atoms x 3x3
2127        Hij = np.squeeze(np.reshape(np.array([G2lat.UijtoU6(uij) for uij in Hij]),(nTwin,-1,6)))
2128        Tuij = np.where(HbH<1.,np.exp(HbH),1.0)     #ops x atoms
2129        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/Uniq.shape[0]  #ops x atoms
2130        fot = (FF+FP-Bab)*Tcorr     #ops x atoms
2131        fotp = FPP*Tcorr            #ops x atoms
2132        GfpuA = G2mth.Modulation(Uniq,UniqP,nWaves,Fmod,Xmod,Umod,glTau,glWt) #2 x sym X atoms
2133        dGdf,dGdx,dGdu,dGdz = G2mth.ModulationDerv(Uniq,UniqP,Hij,nWaves,waveShapes,Fmod,Xmod,UmodAB,SCtauF,SCtauX,SCtauU,glTau,glWt)
2134        # GfpuA is 2 x ops x atoms
2135        # derivs are: ops x atoms x waves x 2,6,12, or 5 parms as [real,imag] parts
2136        fa = np.array([((FF+FP).T-Bab).T*cosp*Tcorr,-Flack*FPP*sinp*Tcorr]) # array(2,nTwin,nEqv,nAtoms)
2137        fb = np.array([((FF+FP).T-Bab).T*sinp*Tcorr,Flack*FPP*cosp*Tcorr])  #or array(2,nEqv,nAtoms)
2138        fag = fa*GfpuA[0]-fb*GfpuA[1]
2139        fbg = fb*GfpuA[0]+fa*GfpuA[1]
2140       
2141        fas = np.sum(np.sum(fag,axis=1),axis=1)     # 2 x twin
2142        fbs = np.sum(np.sum(fbg,axis=1),axis=1)
2143        fax = np.array([-fot*sinp,-fotp*cosp])   #positions; 2 x twin x ops x atoms
2144        fbx = np.array([fot*cosp,-fotp*sinp])
2145        fax = fax*GfpuA[0]-fbx*GfpuA[1]
2146        fbx = fbx*GfpuA[0]+fax*GfpuA[1]
2147        #sum below is over Uniq
2148        dfadfr = np.sum(fag/occ,axis=1)        #Fdata != 0 ever avoids /0. problem
2149        dfbdfr = np.sum(fbg/occ,axis=1)        #Fdata != 0 avoids /0. problem
2150        dfadba = np.sum(-cosp*Tcorr[:,nxs],axis=1)
2151        dfbdba = np.sum(-sinp*Tcorr[:,nxs],axis=1)
2152        dfadui = np.sum(-SQfactor*fag,axis=1)
2153        dfbdui = np.sum(-SQfactor*fbg,axis=1)
2154        dfadx = np.array([np.sum(twopi*Uniq[it,:,:3]*np.swapaxes(fax,-2,-1)[:,it,:,:,nxs],axis=-2) for it in range(nTwin)])
2155        dfbdx = np.array([np.sum(twopi*Uniq[it,:,:3]*np.swapaxes(fbx,-2,-1)[:,it,:,:,nxs],axis=-2) for it in range(nTwin)])           
2156        dfadua = np.array([np.sum(-Hij[it]*np.swapaxes(fag,-2,-1)[:,it,:,:,nxs],axis=-2) for it in range(nTwin)])
2157        dfbdua = np.array([np.sum(-Hij[it]*np.swapaxes(fbg,-2,-1)[:,it,:,:,nxs],axis=-2) for it in range(nTwin)])
2158        # array(2,nTwin,nAtom,3) & array(2,nTwin,nAtom,6) & array(2,nTwin,nAtom,12)
2159        dfadGf = np.sum(fa[:,it,:,:,nxs,nxs]*dGdf[0][nxs,nxs,:,:,:,:]-fb[:,it,:,:,nxs,nxs]*dGdf[1][nxs,nxs,:,:,:,:],axis=1)
2160        dfbdGf = np.sum(fb[:,it,:,:,nxs,nxs]*dGdf[0][nxs,nxs,:,:,:,:]+fa[:,it,:,:,nxs,nxs]*dGdf[1][nxs,nxs,:,:,:,:],axis=1)
2161        dfadGx = np.sum(fa[:,it,:,:,nxs,nxs]*dGdx[0][nxs,nxs,:,:,:,:]-fb[:,it,:,:,nxs,nxs]*dGdx[1][nxs,nxs,:,:,:,:],axis=1)
2162        dfbdGx = np.sum(fb[:,it,:,:,nxs,nxs]*dGdx[0][nxs,nxs,:,:,:,:]+fa[:,it,:,:,nxs,nxs]*dGdx[1][nxs,nxs,:,:,:,:],axis=1)
2163        dfadGz = np.sum(fa[:,it,:,0,nxs,nxs]*dGdz[0][nxs,nxs,:,:,:]-fb[:,it,:,0,nxs,nxs]*dGdz[1][nxs,nxs,:,:,:],axis=1)
2164        dfbdGz = np.sum(fb[:,it,:,0,nxs,nxs]*dGdz[0][nxs,nxs,:,:,:]+fa[:,it,:,0,nxs,nxs]*dGdz[1][nxs,nxs,:,:,:],axis=1)
2165        dfadGu = np.sum(fa[:,it,:,:,nxs,nxs]*dGdu[0][nxs,nxs,:,:,:,:]-fb[:,it,:,:,nxs,nxs]*dGdu[1][nxs,nxs,:,:,:,:],axis=1)
2166        dfbdGu = np.sum(fb[:,it,:,:,nxs,nxs]*dGdu[0][nxs,nxs,:,:,:,:]+fa[:,it,:,:,nxs,nxs]*dGdu[1][nxs,nxs,:,:,:,:],axis=1)
2167#        GSASIIpath.IPyBreak()
2168        #NB: the above have been checked against PA(1:10,1:2) in strfctr.for for Al2O3!   
2169        SA = fas[0]+fas[1]      #float = A+A' (might be array[nTwin])
2170        SB = fbs[0]+fbs[1]      #float = B+B' (might be array[nTwin])
2171        dFdfr[iref] = [2.*TwMask[it]*(SA[it]*dfadfr[0][it]+SA[it]*dfadfr[1][it]+SB[it]*dfbdfr[0][it]+SB[it]*dfbdfr[1][it])*Mdata/len(Uniq[it]) for it in range(nTwin)]
2172        dFdx[iref] = [2.*TwMask[it]*(SA[it]*dfadx[it][0]+SA[it]*dfadx[it][1]+SB[it]*dfbdx[it][0]+SB[it]*dfbdx[it][1]) for it in range(nTwin)]
2173        dFdui[iref] = [2.*TwMask[it]*(SA[it]*dfadui[it][0]+SA[it]*dfadui[it][1]+SB[it]*dfbdui[it][0]+SB[it]*dfbdui[it][1]) for it in range(nTwin)]
2174        dFdua[iref] = [2.*TwMask[it]*(SA[it]*dfadua[it][0]+SA[it]*dfadua[it][1]+SB[it]*dfbdua[it][0]+SB[it]*dfbdua[it][1]) for it in range(nTwin)]
2175        dFdtw[iref] = np.sum(TwMask*fas,axis=0)**2+np.sum(TwMask*fbs,axis=0)**2
2176
2177        dFdGf[iref] = [2.*TwMask[it]*(SA[it]*dfadGf[1]+SB[it]*dfbdGf[1]) for it in range(nTwin)]
2178        dFdGx[iref] = [2.*TwMask[it]*(SA[it]*dfadGx[1]+SB[it]*dfbdGx[1]) for it in range(nTwin)]
2179        dFdGz[iref] = [2.*TwMask[it]*(SA[it]*dfadGz[1]+SB[it]*dfbdGz[1]) for it in range(nTwin)]
2180        dFdGu[iref] = [2.*TwMask[it]*(SA[it]*dfadGu[1]+SB[it]*dfbdGu[1]) for it in range(nTwin)]               
2181#            GSASIIpath.IPyBreak()
2182        dFdbab[iref] = 2.*fas[0]*np.array([np.sum(dfadba*dBabdA),np.sum(-dfadba*parmDict[phfx+'BabA']*SQfactor*dBabdA)]).T+ \
2183            2.*fbs[0]*np.array([np.sum(dfbdba*dBabdA),np.sum(-dfbdba*parmDict[phfx+'BabA']*SQfactor*dBabdA)]).T
2184        #loop over atoms - each dict entry is list of derivatives for all the reflections
2185        if not iref%100 :
2186            print (' %d derivative time %.4f\r'%(iref,time.time()-time0),end='')
2187    for i in range(len(Mdata)):     #loop over atoms
2188        dFdvDict[pfx+'Afrac:'+str(i)] = dFdfr.T[i]
2189        dFdvDict[pfx+'dAx:'+str(i)] = dFdx.T[0][i]
2190        dFdvDict[pfx+'dAy:'+str(i)] = dFdx.T[1][i]
2191        dFdvDict[pfx+'dAz:'+str(i)] = dFdx.T[2][i]
2192        dFdvDict[pfx+'AUiso:'+str(i)] = dFdui.T[i]
2193        dFdvDict[pfx+'AU11:'+str(i)] = dFdua.T[0][i]
2194        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
2195        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
2196        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
2197        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
2198        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
2199        for j in range(FSSdata.shape[1]):        #loop over waves Fzero & Fwid?
2200            dFdvDict[pfx+'Fsin:'+str(i)+':'+str(j)] = dFdGf.T[0][j][i]
2201            dFdvDict[pfx+'Fcos:'+str(i)+':'+str(j)] = dFdGf.T[1][j][i]
2202        nx = 0
2203        if waveTypes[i] in ['Block','ZigZag']:
2204            nx = 1 
2205            dFdvDict[pfx+'Tmin:'+str(i)+':0'] = dFdGz.T[0][i]   #ZigZag/Block waves (if any)
2206            dFdvDict[pfx+'Tmax:'+str(i)+':0'] = dFdGz.T[1][i]
2207            dFdvDict[pfx+'Xmax:'+str(i)+':0'] = dFdGz.T[2][i]
2208            dFdvDict[pfx+'Ymax:'+str(i)+':0'] = dFdGz.T[3][i]
2209            dFdvDict[pfx+'Zmax:'+str(i)+':0'] = dFdGz.T[4][i]
2210        for j in range(XSSdata.shape[1]-nx):       #loop over waves
2211            dFdvDict[pfx+'Xsin:'+str(i)+':'+str(j+nx)] = dFdGx.T[0][j][i]
2212            dFdvDict[pfx+'Ysin:'+str(i)+':'+str(j+nx)] = dFdGx.T[1][j][i]
2213            dFdvDict[pfx+'Zsin:'+str(i)+':'+str(j+nx)] = dFdGx.T[2][j][i]
2214            dFdvDict[pfx+'Xcos:'+str(i)+':'+str(j+nx)] = dFdGx.T[3][j][i]
2215            dFdvDict[pfx+'Ycos:'+str(i)+':'+str(j+nx)] = dFdGx.T[4][j][i]
2216            dFdvDict[pfx+'Zcos:'+str(i)+':'+str(j+nx)] = dFdGx.T[5][j][i]
2217        for j in range(USSdata.shape[1]):       #loop over waves
2218            dFdvDict[pfx+'U11sin:'+str(i)+':'+str(j)] = dFdGu.T[0][j][i]
2219            dFdvDict[pfx+'U22sin:'+str(i)+':'+str(j)] = dFdGu.T[1][j][i]
2220            dFdvDict[pfx+'U33sin:'+str(i)+':'+str(j)] = dFdGu.T[2][j][i]
2221            dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[3][j][i]
2222            dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[4][j][i]
2223            dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[5][j][i]
2224            dFdvDict[pfx+'U11cos:'+str(i)+':'+str(j)] = dFdGu.T[6][j][i]
2225            dFdvDict[pfx+'U22cos:'+str(i)+':'+str(j)] = dFdGu.T[7][j][i]
2226            dFdvDict[pfx+'U33cos:'+str(i)+':'+str(j)] = dFdGu.T[8][j][i]
2227            dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[9][j][i]
2228            dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[10][j][i]
2229            dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[11][j][i]
2230           
2231#        GSASIIpath.IPyBreak()
2232    dFdvDict[phfx+'BabA'] = dFdbab.T[0]
2233    dFdvDict[phfx+'BabU'] = dFdbab.T[1]
2234    return dFdvDict
2235   
2236def SCExtinction(ref,im,phfx,hfx,pfx,calcControls,parmDict,varyList):
2237    ''' Single crystal extinction function; returns extinction & derivative
2238    '''
2239    extCor = 1.0
2240    dervDict = {}
2241    dervCor = 1.0
2242    if calcControls[phfx+'EType'] != 'None':
2243        SQ = 1/(4.*ref[4+im]**2)
2244        if 'C' in parmDict[hfx+'Type']:           
2245            cos2T = 1.0-2.*SQ*parmDict[hfx+'Lam']**2           #cos(2theta)
2246        else:   #'T'
2247            cos2T = 1.0-2.*SQ*ref[12+im]**2                       #cos(2theta)           
2248        if 'SXC' in parmDict[hfx+'Type']:
2249            AV = 7.9406e5/parmDict[pfx+'Vol']**2
2250            PL = np.sqrt(1.0-cos2T**2)/parmDict[hfx+'Lam']
2251            P12 = (calcControls[phfx+'Cos2TM']+cos2T**4)/(calcControls[phfx+'Cos2TM']+cos2T**2)
2252            PLZ = AV*P12*ref[9+im]*parmDict[hfx+'Lam']**2
2253        elif 'SNT' in parmDict[hfx+'Type']:
2254            AV = 1.e7/parmDict[pfx+'Vol']**2
2255            PL = SQ
2256            PLZ = AV*ref[9+im]*ref[12+im]**2
2257        elif 'SNC' in parmDict[hfx+'Type']:
2258            AV = 1.e7/parmDict[pfx+'Vol']**2
2259            PL = np.sqrt(1.0-cos2T**2)/parmDict[hfx+'Lam']
2260            PLZ = AV*ref[9+im]*parmDict[hfx+'Lam']**2
2261           
2262        if 'Primary' in calcControls[phfx+'EType']:
2263            PLZ *= 1.5
2264        else:
2265            if 'C' in parmDict[hfx+'Type']:
2266                PLZ *= calcControls[phfx+'Tbar']
2267            else: #'T'
2268                PLZ *= ref[13+im]      #t-bar
2269        if 'Primary' in calcControls[phfx+'EType']:
2270            PLZ *= 1.5
2271            PSIG = parmDict[phfx+'Ep']
2272        elif 'I & II' in calcControls[phfx+'EType']:
2273            PSIG = parmDict[phfx+'Eg']/np.sqrt(1.+(parmDict[phfx+'Es']*PL/parmDict[phfx+'Eg'])**2)
2274        elif 'Type II' in calcControls[phfx+'EType']:
2275            PSIG = parmDict[phfx+'Es']
2276        else:       # 'Secondary Type I'
2277            PSIG = parmDict[phfx+'Eg']/PL
2278           
2279        AG = 0.58+0.48*cos2T+0.24*cos2T**2
2280        AL = 0.025+0.285*cos2T
2281        BG = 0.02-0.025*cos2T
2282        BL = 0.15-0.2*(0.75-cos2T)**2
2283        if cos2T < 0.:
2284            BL = -0.45*cos2T
2285        CG = 2.
2286        CL = 2.
2287        PF = PLZ*PSIG
2288       
2289        if 'Gaussian' in calcControls[phfx+'EApprox']:
2290            PF4 = 1.+CG*PF+AG*PF**2/(1.+BG*PF)
2291            extCor = np.sqrt(PF4)
2292            PF3 = 0.5*(CG+2.*AG*PF/(1.+BG*PF)-AG*PF**2*BG/(1.+BG*PF)**2)/(PF4*extCor)
2293        else:
2294            PF4 = 1.+CL*PF+AL*PF**2/(1.+BL*PF)
2295            extCor = np.sqrt(PF4)
2296            PF3 = 0.5*(CL+2.*AL*PF/(1.+BL*PF)-AL*PF**2*BL/(1.+BL*PF)**2)/(PF4*extCor)
2297
2298        dervCor = (1.+PF)*PF3   #extinction corr for other derivatives
2299        if 'Primary' in calcControls[phfx+'EType'] and phfx+'Ep' in varyList:
2300            dervDict[phfx+'Ep'] = -ref[7+im]*PLZ*PF3
2301        if 'II' in calcControls[phfx+'EType'] and phfx+'Es' in varyList:
2302            dervDict[phfx+'Es'] = -ref[7+im]*PLZ*PF3*(PSIG/parmDict[phfx+'Es'])**3
2303        if 'I' in calcControls[phfx+'EType'] and phfx+'Eg' in varyList:
2304            dervDict[phfx+'Eg'] = -ref[7+im]*PLZ*PF3*(PSIG/parmDict[phfx+'Eg'])**3*PL**2
2305               
2306    return 1./extCor,dervDict,dervCor
2307   
2308def Dict2Values(parmdict, varylist):
2309    '''Use before call to leastsq to setup list of values for the parameters
2310    in parmdict, as selected by key in varylist'''
2311    return [parmdict[key] for key in varylist] 
2312   
2313def Values2Dict(parmdict, varylist, values):
2314    ''' Use after call to leastsq to update the parameter dictionary with
2315    values corresponding to keys in varylist'''
2316    parmdict.update(zip(varylist,values))
2317   
2318def GetNewCellParms(parmDict,varyList):
2319    '''Compute unit cell tensor terms from varied Aij and Dij values.
2320    Terms are included in the dict only if Aij or Dij is varied.
2321    '''
2322    newCellDict = {}
2323    Anames = ['A'+str(i) for i in range(6)]
2324    Ddict = dict(zip(['D11','D22','D33','D12','D13','D23'],Anames))
2325    for item in varyList:
2326        keys = item.split(':')
2327        if keys[2] in Ddict:
2328            key = keys[0]+'::'+Ddict[keys[2]]       #key is e.g. '0::A0'
2329            parm = keys[0]+'::'+keys[2]             #parm is e.g. '0::D11'
2330            newCellDict[parm] = [key,parmDict[key]+parmDict[item]]
2331    return newCellDict          # is e.g. {'0::D11':A0-D11}
2332   
2333def ApplyXYZshifts(parmDict,varyList):
2334    '''
2335    takes atom x,y,z shift and applies it to corresponding atom x,y,z value
2336   
2337    :param dict parmDict: parameter dictionary
2338    :param list varyList: list of variables (not used!)
2339    :returns: newAtomDict - dictionary of new atomic coordinate names & values; key is parameter shift name
2340
2341    '''
2342    newAtomDict = {}
2343    for item in parmDict:
2344        if 'dA' in item:
2345            parm = ''.join(item.split('d'))
2346            parmDict[parm] += parmDict[item]
2347            newAtomDict[item] = [parm,parmDict[parm]]
2348    return newAtomDict
2349   
2350def SHTXcal(refl,im,g,pfx,hfx,SGData,calcControls,parmDict):
2351    'Spherical harmonics texture'
2352    IFCoup = 'Bragg' in calcControls[hfx+'instType']
2353    if 'T' in calcControls[hfx+'histType']:
2354        tth = parmDict[hfx+'2-theta']
2355    else:
2356        tth = refl[5+im]
2357    odfCor = 1.0
2358    H = refl[:3]
2359    cell = G2lat.Gmat2cell(g)
2360    Sangls = [parmDict[pfx+'SH omega'],parmDict[pfx+'SH chi'],parmDict[pfx+'SH phi']]
2361    Gangls = [parmDict[hfx+'Phi'],parmDict[hfx+'Chi'],parmDict[hfx+'Omega'],parmDict[hfx+'Azimuth']]
2362    phi,beta = G2lat.CrsAng(H,cell,SGData)
2363    psi,gam,x,x = G2lat.SamAng(tth/2.,Gangls,Sangls,IFCoup) #ignore 2 sets of angle derivs.
2364    SHnames = G2lat.GenSHCoeff(SGData['SGLaue'],parmDict[pfx+'SHmodel'],parmDict[pfx+'SHorder'])
2365    for item in SHnames:
2366        L,M,N = eval(item.strip('C'))
2367        Kcl = G2lat.GetKcl(L,N,SGData['SGLaue'],phi,beta)
2368        Ksl,x,x = G2lat.GetKsl(L,M,parmDict[pfx+'SHmodel'],psi,gam)
2369        Lnorm = G2lat.Lnorm(L)
2370        odfCor += parmDict[pfx+item]*Lnorm*Kcl*Ksl
2371    return odfCor
2372   
2373def SHTXcalDerv(refl,im,g,pfx,hfx,SGData,calcControls,parmDict):
2374    'Spherical harmonics texture derivatives'
2375    if 'T' in calcControls[hfx+'histType']:
2376        tth = parmDict[hfx+'2-theta']
2377    else:
2378        tth = refl[5+im]
2379    IFCoup = 'Bragg' in calcControls[hfx+'instType']
2380    odfCor = 1.0
2381    dFdODF = {}
2382    dFdSA = [0,0,0]
2383    H = refl[:3]
2384    cell = G2lat.Gmat2cell(g)
2385    Sangls = [parmDict[pfx+'SH omega'],parmDict[pfx+'SH chi'],parmDict[pfx+'SH phi']]
2386    Gangls = [parmDict[hfx+'Phi'],parmDict[hfx+'Chi'],parmDict[hfx+'Omega'],parmDict[hfx+'Azimuth']]
2387    phi,beta = G2lat.CrsAng(H,cell,SGData)
2388    psi,gam,dPSdA,dGMdA = G2lat.SamAng(tth/2.,Gangls,Sangls,IFCoup)
2389    SHnames = G2lat.GenSHCoeff(SGData['SGLaue'],parmDict[pfx+'SHmodel'],parmDict[pfx+'SHorder'])
2390    for item in SHnames:
2391        L,M,N = eval(item.strip('C'))
2392        Kcl = G2lat.GetKcl(L,N,SGData['SGLaue'],phi,beta)
2393        Ksl,dKsdp,dKsdg = G2lat.GetKsl(L,M,parmDict[pfx+'SHmodel'],psi,gam)
2394        Lnorm = G2lat.Lnorm(L)
2395        odfCor += parmDict[pfx+item]*Lnorm*Kcl*Ksl
2396        dFdODF[pfx+item] = Lnorm*Kcl*Ksl
2397        for i in range(3):
2398            dFdSA[i] += parmDict[pfx+item]*Lnorm*Kcl*(dKsdp*dPSdA[i]+dKsdg*dGMdA[i])
2399    return odfCor,dFdODF,dFdSA
2400   
2401def SHPOcal(refl,im,g,phfx,hfx,SGData,calcControls,parmDict):
2402    'spherical harmonics preferred orientation (cylindrical symmetry only)'
2403    if 'T' in calcControls[hfx+'histType']:
2404        tth = parmDict[hfx+'2-theta']
2405    else:
2406        tth = refl[5+im]
2407    odfCor = 1.0
2408    H = refl[:3]
2409    cell = G2lat.Gmat2cell(g)
2410    Sangls = [0.,0.,0.]
2411    if 'Bragg' in calcControls[hfx+'instType']:
2412        Gangls = [0.,90.,0.,parmDict[hfx+'Azimuth']]
2413        IFCoup = True
2414    else:
2415        Gangls = [parmDict[hfx+'Phi'],parmDict[hfx+'Chi'],parmDict[hfx+'Omega'],parmDict[hfx+'Azimuth']]
2416        IFCoup = False
2417    phi,beta = G2lat.CrsAng(H,cell,SGData)
2418    psi,gam,x,x = G2lat.SamAng(tth/2.,Gangls,Sangls,IFCoup) #ignore 2 sets of angle derivs.
2419    SHnames = calcControls[phfx+'SHnames']
2420    for item in SHnames:
2421        L,N = eval(item.strip('C'))
2422        Kcl = G2lat.GetKcl(L,N,SGData['SGLaue'],phi,beta)
2423        Ksl,x,x = G2lat.GetKsl(L,0,'0',psi,gam)
2424        Lnorm = G2lat.Lnorm(L)
2425        odfCor += parmDict[phfx+item]*Lnorm*Kcl*Ksl
2426    return np.squeeze(odfCor)
2427   
2428def SHPOcalDerv(refl,im,g,phfx,hfx,SGData,calcControls,parmDict):
2429    'spherical harmonics preferred orientation derivatives (cylindrical symmetry only)'
2430    if 'T' in calcControls[hfx+'histType']:
2431        tth = parmDict[hfx+'2-theta']
2432    else:
2433        tth = refl[5+im]
2434    odfCor = 1.0
2435    dFdODF = {}
2436    H = refl[:3]
2437    cell = G2lat.Gmat2cell(g)
2438    Sangls = [0.,0.,0.]
2439    if 'Bragg' in calcControls[hfx+'instType']:
2440        Gangls = [0.,90.,0.,parmDict[hfx+'Azimuth']]
2441        IFCoup = True
2442    else:
2443        Gangls = [parmDict[hfx+'Phi'],parmDict[hfx+'Chi'],parmDict[hfx+'Omega'],parmDict[hfx+'Azimuth']]
2444        IFCoup = False
2445    phi,beta = G2lat.CrsAng(H,cell,SGData)
2446    psi,gam,x,x = G2lat.SamAng(tth/2.,Gangls,Sangls,IFCoup) #ignore 2 sets of angle derivs.
2447    SHnames = calcControls[phfx+'SHnames']
2448    for item in SHnames:
2449        L,N = eval(item.strip('C'))
2450        Kcl = G2lat.GetKcl(L,N,SGData['SGLaue'],phi,beta)
2451        Ksl,x,x = G2lat.GetKsl(L,0,'0',psi,gam)
2452        Lnorm = G2lat.Lnorm(L)
2453        odfCor += parmDict[phfx+item]*Lnorm*Kcl*Ksl
2454        dFdODF[phfx+item] = Kcl*Ksl*Lnorm
2455    return odfCor,dFdODF
2456   
2457def GetPrefOri(uniq,G,g,phfx,hfx,SGData,calcControls,parmDict):
2458    'March-Dollase preferred orientation correction'
2459    POcorr = 1.0
2460    MD = parmDict[phfx+'MD']
2461    if MD != 1.0:
2462        MDAxis = calcControls[phfx+'MDAxis']
2463        sumMD = 0
2464        for H in uniq:           
2465            cosP,sinP = G2lat.CosSinAngle(H,MDAxis,G)
2466            A = 1.0/np.sqrt((MD*cosP)**2+sinP**2/MD)
2467            sumMD += A**3
2468        POcorr = sumMD/len(uniq)
2469    return POcorr
2470   
2471def GetPrefOriDerv(refl,im,uniq,G,g,phfx,hfx,SGData,calcControls,parmDict):
2472    'Needs a doc string'
2473    POcorr = 1.0
2474    POderv = {}
2475    if calcControls[phfx+'poType'] == 'MD':
2476        MD = parmDict[phfx+'MD']
2477        MDAxis = calcControls[phfx+'MDAxis']
2478        sumMD = 0
2479        sumdMD = 0
2480        for H in uniq:           
2481            cosP,sinP = G2lat.CosSinAngle(H,MDAxis,G)
2482            A = 1.0/np.sqrt((MD*cosP)**2+sinP**2/MD)
2483            sumMD += A**3
2484            sumdMD -= (1.5*A**5)*(2.0*MD*cosP**2-(sinP/MD)**2)
2485        POcorr = sumMD/len(uniq)
2486        POderv[phfx+'MD'] = sumdMD/len(uniq)
2487    else:   #spherical harmonics
2488        if calcControls[phfx+'SHord']:
2489            POcorr,POderv = SHPOcalDerv(refl,im,g,phfx,hfx,SGData,calcControls,parmDict)
2490    return POcorr,POderv
2491   
2492def GetAbsorb(refl,im,hfx,calcControls,parmDict):
2493    'Needs a doc string'
2494    if 'Debye' in calcControls[hfx+'instType']:
2495        if 'T' in calcControls[hfx+'histType']:
2496            return G2pwd.Absorb('Cylinder',parmDict[hfx+'Absorption']*refl[14+im],abs(parmDict[hfx+'2-theta']),0,0)
2497        else:
2498            return G2pwd.Absorb('Cylinder',parmDict[hfx+'Absorption'],refl[5+im],0,0)
2499    else:
2500        return G2pwd.SurfaceRough(parmDict[hfx+'SurfRoughA'],parmDict[hfx+'SurfRoughB'],refl[5+im])
2501   
2502def GetAbsorbDerv(refl,im,hfx,calcControls,parmDict):
2503    'Needs a doc string'
2504    if 'Debye' in calcControls[hfx+'instType']:
2505        if 'T' in calcControls[hfx+'histType']:
2506            return G2pwd.AbsorbDerv('Cylinder',parmDict[hfx+'Absorption']*refl[14+im],abs(parmDict[hfx+'2-theta']),0,0)
2507        else:
2508            return G2pwd.AbsorbDerv('Cylinder',parmDict[hfx+'Absorption'],refl[5+im],0,0)
2509    else:
2510        return np.array(G2pwd.SurfaceRoughDerv(parmDict[hfx+'SurfRoughA'],parmDict[hfx+'SurfRoughB'],refl[5+im]))
2511       
2512def GetPwdrExt(refl,im,pfx,phfx,hfx,calcControls,parmDict):
2513    'Needs a doc string'
2514    coef = np.array([-0.5,0.25,-0.10416667,0.036458333,-0.0109375,2.8497409E-3])
2515    pi2 = np.sqrt(2./np.pi)
2516    if 'T' in calcControls[hfx+'histType']:
2517        sth2 = sind(abs(parmDict[hfx+'2-theta'])/2.)**2
2518        wave = refl[14+im]
2519    else:   #'C'W
2520        sth2 = sind(refl[5+im]/2.)**2
2521        wave = parmDict.get(hfx+'Lam',parmDict.get(hfx+'Lam1',1.0))
2522    c2th = 1.-2.0*sth2
2523    flv2 = refl[9+im]*(wave/parmDict[pfx+'Vol'])**2
2524    if 'X' in calcControls[hfx+'histType']:
2525        flv2 *= 0.079411*(1.0+c2th**2)/2.0
2526    xfac = flv2*parmDict[phfx+'Extinction']
2527    exb = 1.0
2528    if xfac > -1.:
2529        exb = 1./np.sqrt(1.+xfac)
2530    exl = 1.0
2531    if 0 < xfac <= 1.:
2532        xn = np.array([xfac**(i+1) for i in range(6)])
2533        exl += np.sum(xn*coef)
2534    elif xfac > 1.:
2535        xfac2 = 1./np.sqrt(xfac)
2536        exl = pi2*(1.-0.125/xfac)*xfac2
2537    return exb*sth2+exl*(1.-sth2)
2538   
2539def GetPwdrExtDerv(refl,im,pfx,phfx,hfx,calcControls,parmDict):
2540    'Needs a doc string'
2541    coef = np.array([-0.5,0.25,-0.10416667,0.036458333,-0.0109375,2.8497409E-3])
2542    pi2 = np.sqrt(2./np.pi)
2543    if 'T' in calcControls[hfx+'histType']:
2544        sth2 = sind(abs(parmDict[hfx+'2-theta'])/2.)**2
2545        wave = refl[14+im]
2546    else:   #'C'W
2547        sth2 = sind(refl[5+im]/2.)**2
2548        wave = parmDict.get(hfx+'Lam',parmDict.get(hfx+'Lam1',1.0))
2549    c2th = 1.-2.0*sth2
2550    flv2 = refl[9+im]*(wave/parmDict[pfx+'Vol'])**2
2551    if 'X' in calcControls[hfx+'histType']:
2552        flv2 *= 0.079411*(1.0+c2th**2)/2.0
2553    xfac = flv2*parmDict[phfx+'Extinction']
2554    dbde = -500.*flv2
2555    if xfac > -1.:
2556        dbde = -0.5*flv2/np.sqrt(1.+xfac)**3
2557    dlde = 0.
2558    if 0 < xfac <= 1.:
2559        xn = np.array([i*flv2*xfac**i for i in [1,2,3,4,5,6]])
2560        dlde = np.sum(xn*coef)
2561    elif xfac > 1.:
2562        xfac2 = 1./np.sqrt(xfac)
2563        dlde = flv2*pi2*xfac2*(-1./xfac+0.375/xfac**2)
2564       
2565    return dbde*sth2+dlde*(1.-sth2)
2566   
2567def GetIntensityCorr(refl,im,uniq,G,g,pfx,phfx,hfx,SGData,calcControls,parmDict):
2568    'Needs a doc string'    #need powder extinction!
2569    Icorr = parmDict[phfx+'Scale']*parmDict[hfx+'Scale']*refl[3+im]               #scale*multiplicity
2570    if 'X' in parmDict[hfx+'Type']:
2571        Icorr *= G2pwd.Polarization(parmDict[hfx+'Polariz.'],refl[5+im],parmDict[hfx+'Azimuth'])[0]
2572    POcorr = 1.0
2573    if pfx+'SHorder' in parmDict:                 #generalized spherical harmonics texture - takes precidence
2574        POcorr = SHTXcal(refl,im,g,pfx,hfx,SGData,calcControls,parmDict)
2575    elif calcControls[phfx+'poType'] == 'MD':         #March-Dollase
2576        POcorr = GetPrefOri(uniq,G,g,phfx,hfx,SGData,calcControls,parmDict)
2577    elif calcControls[phfx+'SHord']:                #cylindrical spherical harmonics
2578        POcorr = SHPOcal(refl,im,g,phfx,hfx,SGData,calcControls,parmDict)
2579    Icorr *= POcorr
2580    AbsCorr = 1.0
2581    AbsCorr = GetAbsorb(refl,im,hfx,calcControls,parmDict)
2582    Icorr *= AbsCorr
2583    ExtCorr = GetPwdrExt(refl,im,pfx,phfx,hfx,calcControls,parmDict)
2584    Icorr *= ExtCorr
2585    return Icorr,POcorr,AbsCorr,ExtCorr
2586   
2587def GetIntensityDerv(refl,im,wave,uniq,G,g,pfx,phfx,hfx,SGData,calcControls,parmDict):
2588    'Needs a doc string'    #need powder extinction derivs!
2589    dIdsh = 1./parmDict[hfx+'Scale']
2590    dIdsp = 1./parmDict[phfx+'Scale']
2591    if 'X' in parmDict[hfx+'Type']:
2592        pola,dIdPola = G2pwd.Polarization(parmDict[hfx+'Polariz.'],refl[5+im],parmDict[hfx+'Azimuth'])
2593        dIdPola /= pola
2594    else:       #'N'
2595        dIdPola = 0.0
2596    dFdODF = {}
2597    dFdSA = [0,0,0]
2598    dIdPO = {}
2599    if pfx+'SHorder' in parmDict:
2600        odfCor,dFdODF,dFdSA = SHTXcalDerv(refl,im,g,pfx,hfx,SGData,calcControls,parmDict)
2601        for iSH in dFdODF:
2602            dFdODF[iSH] /= odfCor
2603        for i in range(3):
2604            dFdSA[i] /= odfCor
2605    elif calcControls[phfx+'poType'] == 'MD' or calcControls[phfx+'SHord']:
2606        POcorr,dIdPO = GetPrefOriDerv(refl,im,uniq,G,g,phfx,hfx,SGData,calcControls,parmDict)       
2607        for iPO in dIdPO:
2608            dIdPO[iPO] /= POcorr
2609    if 'T' in parmDict[hfx+'Type']:
2610        dFdAb = GetAbsorbDerv(refl,im,hfx,calcControls,parmDict)*wave/refl[16+im] #wave/abs corr
2611        dFdEx = GetPwdrExtDerv(refl,im,pfx,phfx,hfx,calcControls,parmDict)/refl[17+im]    #/ext corr
2612    else:
2613        dFdAb = GetAbsorbDerv(refl,im,hfx,calcControls,parmDict)*wave/refl[13+im] #wave/abs corr
2614        dFdEx = GetPwdrExtDerv(refl,im,pfx,phfx,hfx,calcControls,parmDict)/refl[14+im]    #/ext corr       
2615    return dIdsh,dIdsp,dIdPola,dIdPO,dFdODF,dFdSA,dFdAb,dFdEx
2616       
2617def GetSampleSigGam(refl,im,wave,G,GB,SGData,hfx,phfx,calcControls,parmDict):
2618    'Needs a doc string'
2619    if 'C' in calcControls[hfx+'histType']:     #All checked & OK
2620        costh = cosd(refl[5+im]/2.)
2621        #crystallite size
2622        if calcControls[phfx+'SizeType'] == 'isotropic':
2623            Sgam = 1.8*wave/(np.pi*parmDict[phfx+'Size;i']*costh)
2624        elif calcControls[phfx+'SizeType'] == 'uniaxial':
2625            H = np.array(refl[:3])
2626            P = np.array(calcControls[phfx+'SizeAxis'])
2627            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2628            Sgam = (1.8*wave/np.pi)/(parmDict[phfx+'Size;i']*parmDict[phfx+'Size;a']*costh)
2629            Sgam *= np.sqrt((sinP*parmDict[phfx+'Size;a'])**2+(cosP*parmDict[phfx+'Size;i'])**2)
2630        else:           #ellipsoidal crystallites
2631            Sij =[parmDict[phfx+'Size;%d'%(i)] for i in range(6)]
2632            H = np.array(refl[:3])
2633            lenR = G2pwd.ellipseSize(H,Sij,GB)
2634            Sgam = 1.8*wave/(np.pi*costh*lenR)
2635        #microstrain               
2636        if calcControls[phfx+'MustrainType'] == 'isotropic':
2637            Mgam = 0.018*parmDict[phfx+'Mustrain;i']*tand(refl[5+im]/2.)/np.pi
2638        elif calcControls[phfx+'MustrainType'] == 'uniaxial':
2639            H = np.array(refl[:3])
2640            P = np.array(calcControls[phfx+'MustrainAxis'])
2641            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2642            Si = parmDict[phfx+'Mustrain;i']
2643            Sa = parmDict[phfx+'Mustrain;a']
2644            Mgam = 0.018*Si*Sa*tand(refl[5+im]/2.)/(np.pi*np.sqrt((Si*cosP)**2+(Sa*sinP)**2))
2645        else:       #generalized - P.W. Stephens model
2646            Strms = G2spc.MustrainCoeff(refl[:3],SGData)
2647            Sum = 0
2648            for i,strm in enumerate(Strms):
2649                Sum += parmDict[phfx+'Mustrain;'+str(i)]*strm
2650            Mgam = 0.018*refl[4+im]**2*tand(refl[5+im]/2.)*np.sqrt(Sum)/np.pi
2651    elif 'T' in calcControls[hfx+'histType']:       #All checked & OK
2652        #crystallite size
2653        if calcControls[phfx+'SizeType'] == 'isotropic':    #OK
2654            Sgam = 1.e-4*parmDict[hfx+'difC']*refl[4+im]**2/parmDict[phfx+'Size;i']
2655        elif calcControls[phfx+'SizeType'] == 'uniaxial':   #OK
2656            H = np.array(refl[:3])
2657            P = np.array(calcControls[phfx+'SizeAxis'])
2658            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2659            Sgam = 1.e-4*parmDict[hfx+'difC']*refl[4+im]**2/(parmDict[phfx+'Size;i']*parmDict[phfx+'Size;a'])
2660            Sgam *= np.sqrt((sinP*parmDict[phfx+'Size;a'])**2+(cosP*parmDict[phfx+'Size;i'])**2)
2661        else:           #ellipsoidal crystallites   #OK
2662            Sij =[parmDict[phfx+'Size;%d'%(i)] for i in range(6)]
2663            H = np.array(refl[:3])
2664            lenR = G2pwd.ellipseSize(H,Sij,GB)
2665            Sgam = 1.e-4*parmDict[hfx+'difC']*refl[4+im]**2/lenR
2666        #microstrain               
2667        if calcControls[phfx+'MustrainType'] == 'isotropic':    #OK
2668            Mgam = 1.e-6*parmDict[hfx+'difC']*refl[4+im]*parmDict[phfx+'Mustrain;i']
2669        elif calcControls[phfx+'MustrainType'] == 'uniaxial':   #OK
2670            H = np.array(refl[:3])
2671            P = np.array(calcControls[phfx+'MustrainAxis'])
2672            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2673            Si = parmDict[phfx+'Mustrain;i']
2674            Sa = parmDict[phfx+'Mustrain;a']
2675            Mgam = 1.e-6*parmDict[hfx+'difC']*refl[4+im]*Si*Sa/np.sqrt((Si*cosP)**2+(Sa*sinP)**2)
2676        else:       #generalized - P.W. Stephens model  OK
2677            Strms = G2spc.MustrainCoeff(refl[:3],SGData)
2678            Sum = 0
2679            for i,strm in enumerate(Strms):
2680                Sum += parmDict[phfx+'Mustrain;'+str(i)]*strm
2681            Mgam = 1.e-6*parmDict[hfx+'difC']*np.sqrt(Sum)*refl[4+im]**3
2682           
2683    gam = Sgam*parmDict[phfx+'Size;mx']+Mgam*parmDict[phfx+'Mustrain;mx']
2684    sig = (Sgam*(1.-parmDict[phfx+'Size;mx']))**2+(Mgam*(1.-parmDict[phfx+'Mustrain;mx']))**2
2685    sig /= ateln2
2686    return sig,gam
2687       
2688def GetSampleSigGamDerv(refl,im,wave,G,GB,SGData,hfx,phfx,calcControls,parmDict):
2689    'Needs a doc string'
2690    gamDict = {}
2691    sigDict = {}
2692    if 'C' in calcControls[hfx+'histType']:         #All checked & OK
2693        costh = cosd(refl[5+im]/2.)
2694        tanth = tand(refl[5+im]/2.)
2695        #crystallite size derivatives
2696        if calcControls[phfx+'SizeType'] == 'isotropic':
2697            Sgam = 1.8*wave/(np.pi*costh*parmDict[phfx+'Size;i'])
2698            gamDict[phfx+'Size;i'] = -1.8*wave*parmDict[phfx+'Size;mx']/(np.pi*costh*parmDict[phfx+'Size;i']**2)
2699            sigDict[phfx+'Size;i'] = -3.6*Sgam*wave*(1.-parmDict[phfx+'Size;mx'])**2/(np.pi*costh*ateln2)
2700        elif calcControls[phfx+'SizeType'] == 'uniaxial':
2701            H = np.array(refl[:3])
2702            P = np.array(calcControls[phfx+'SizeAxis'])
2703            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2704            Si = parmDict[phfx+'Size;i']
2705            Sa = parmDict[phfx+'Size;a']
2706            gami = 1.8*wave/(costh*np.pi*Si*Sa)
2707            sqtrm = np.sqrt((sinP*Sa)**2+(cosP*Si)**2)
2708            Sgam = gami*sqtrm
2709            dsi = gami*Si*cosP**2/sqtrm-Sgam/Si
2710            dsa = gami*Sa*sinP**2/sqtrm-Sgam/Sa
2711            gamDict[phfx+'Size;i'] = dsi*parmDict[phfx+'Size;mx']
2712            gamDict[phfx+'Size;a'] = dsa*parmDict[phfx+'Size;mx']
2713            sigDict[phfx+'Size;i'] = 2.*dsi*Sgam*(1.-parmDict[phfx+'Size;mx'])**2/ateln2
2714            sigDict[phfx+'Size;a'] = 2.*dsa*Sgam*(1.-parmDict[phfx+'Size;mx'])**2/ateln2
2715        else:           #ellipsoidal crystallites
2716            const = 1.8*wave/(np.pi*costh)
2717            Sij =[parmDict[phfx+'Size;%d'%(i)] for i in range(6)]
2718            H = np.array(refl[:3])
2719            lenR,dRdS = G2pwd.ellipseSizeDerv(H,Sij,GB)
2720            Sgam = const/lenR
2721            for i,item in enumerate([phfx+'Size;%d'%(j) for j in range(6)]):
2722                gamDict[item] = -(const/lenR**2)*dRdS[i]*parmDict[phfx+'Size;mx']
2723                sigDict[item] = -2.*Sgam*(const/lenR**2)*dRdS[i]*(1.-parmDict[phfx+'Size;mx'])**2/ateln2
2724        gamDict[phfx+'Size;mx'] = Sgam
2725        sigDict[phfx+'Size;mx'] = -2.*Sgam**2*(1.-parmDict[phfx+'Size;mx'])/ateln2
2726               
2727        #microstrain derivatives               
2728        if calcControls[phfx+'MustrainType'] == 'isotropic':
2729            Mgam = 0.018*parmDict[phfx+'Mustrain;i']*tand(refl[5+im]/2.)/np.pi
2730            gamDict[phfx+'Mustrain;i'] =  0.018*tanth*parmDict[phfx+'Mustrain;mx']/np.pi
2731            sigDict[phfx+'Mustrain;i'] =  0.036*Mgam*tanth*(1.-parmDict[phfx+'Mustrain;mx'])**2/(np.pi*ateln2)       
2732        elif calcControls[phfx+'MustrainType'] == 'uniaxial':
2733            H = np.array(refl[:3])
2734            P = np.array(calcControls[phfx+'MustrainAxis'])
2735            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2736            Si = parmDict[phfx+'Mustrain;i']
2737            Sa = parmDict[phfx+'Mustrain;a']
2738            gami = 0.018*Si*Sa*tanth/np.pi
2739            sqtrm = np.sqrt((Si*cosP)**2+(Sa*sinP)**2)
2740            Mgam = gami/sqtrm
2741            dsi = -gami*Si*cosP**2/sqtrm**3
2742            dsa = -gami*Sa*sinP**2/sqtrm**3
2743            gamDict[phfx+'Mustrain;i'] = (Mgam/Si+dsi)*parmDict[phfx+'Mustrain;mx']
2744            gamDict[phfx+'Mustrain;a'] = (Mgam/Sa+dsa)*parmDict[phfx+'Mustrain;mx']
2745            sigDict[phfx+'Mustrain;i'] = 2*(Mgam/Si+dsi)*Mgam*(1.-parmDict[phfx+'Mustrain;mx'])**2/ateln2
2746            sigDict[phfx+'Mustrain;a'] = 2*(Mgam/Sa+dsa)*Mgam*(1.-parmDict[phfx+'Mustrain;mx'])**2/ateln2       
2747        else:       #generalized - P.W. Stephens model
2748            const = 0.018*refl[4+im]**2*tanth/np.pi
2749            Strms = G2spc.MustrainCoeff(refl[:3],SGData)
2750            Sum = 0
2751            for i,strm in enumerate(Strms):
2752                Sum += parmDict[phfx+'Mustrain;'+str(i)]*strm
2753                gamDict[phfx+'Mustrain;'+str(i)] = strm*parmDict[phfx+'Mustrain;mx']/2.
2754                sigDict[phfx+'Mustrain;'+str(i)] = strm*(1.-parmDict[phfx+'Mustrain;mx'])**2
2755            Mgam = const*np.sqrt(Sum)
2756            for i in range(len(Strms)):
2757                gamDict[phfx+'Mustrain;'+str(i)] *= Mgam/Sum
2758                sigDict[phfx+'Mustrain;'+str(i)] *= const**2/ateln2
2759        gamDict[phfx+'Mustrain;mx'] = Mgam
2760        sigDict[phfx+'Mustrain;mx'] = -2.*Mgam**2*(1.-parmDict[phfx+'Mustrain;mx'])/ateln2
2761    else:   #'T'OF - All checked & OK
2762        if calcControls[phfx+'SizeType'] == 'isotropic':    #OK
2763            Sgam = 1.e-4*parmDict[hfx+'difC']*refl[4+im]**2/parmDict[phfx+'Size;i']
2764            gamDict[phfx+'Size;i'] = -Sgam*parmDict[phfx+'Size;mx']/parmDict[phfx+'Size;i']
2765            sigDict[phfx+'Size;i'] = -2.*Sgam**2*(1.-parmDict[phfx+'Size;mx'])**2/(ateln2*parmDict[phfx+'Size;i'])
2766        elif calcControls[phfx+'SizeType'] == 'uniaxial':   #OK
2767            const = 1.e-4*parmDict[hfx+'difC']*refl[4+im]**2
2768            H = np.array(refl[:3])
2769            P = np.array(calcControls[phfx+'SizeAxis'])
2770            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2771            Si = parmDict[phfx+'Size;i']
2772            Sa = parmDict[phfx+'Size;a']
2773            gami = const/(Si*Sa)
2774            sqtrm = np.sqrt((sinP*Sa)**2+(cosP*Si)**2)
2775            Sgam = gami*sqtrm
2776            dsi = gami*Si*cosP**2/sqtrm-Sgam/Si
2777            dsa = gami*Sa*sinP**2/sqtrm-Sgam/Sa
2778            gamDict[phfx+'Size;i'] = dsi*parmDict[phfx+'Size;mx']
2779            gamDict[phfx+'Size;a'] = dsa*parmDict[phfx+'Size;mx']
2780            sigDict[phfx+'Size;i'] = 2.*dsi*Sgam*(1.-parmDict[phfx+'Size;mx'])**2/ateln2
2781            sigDict[phfx+'Size;a'] = 2.*dsa*Sgam*(1.-parmDict[phfx+'Size;mx'])**2/ateln2
2782        else:           #OK  ellipsoidal crystallites
2783            const = 1.e-4*parmDict[hfx+'difC']*refl[4+im]**2
2784            Sij =[parmDict[phfx+'Size;%d'%(i)] for i in range(6)]
2785            H = np.array(refl[:3])
2786            lenR,dRdS = G2pwd.ellipseSizeDerv(H,Sij,GB)
2787            Sgam = const/lenR
2788            for i,item in enumerate([phfx+'Size;%d'%(j) for j in range(6)]):
2789                gamDict[item] = -(const/lenR**2)*dRdS[i]*parmDict[phfx+'Size;mx']
2790                sigDict[item] = -2.*Sgam*(const/lenR**2)*dRdS[i]*(1.-parmDict[phfx+'Size;mx'])**2/ateln2
2791        gamDict[phfx+'Size;mx'] = Sgam  #OK
2792        sigDict[phfx+'Size;mx'] = -2.*Sgam**2*(1.-parmDict[phfx+'Size;mx'])/ateln2  #OK
2793               
2794        #microstrain derivatives               
2795        if calcControls[phfx+'MustrainType'] == 'isotropic':
2796            Mgam = 1.e-6*parmDict[hfx+'difC']*refl[4+im]*parmDict[phfx+'Mustrain;i']
2797            gamDict[phfx+'Mustrain;i'] =  1.e-6*refl[4+im]*parmDict[hfx+'difC']*parmDict[phfx+'Mustrain;mx']   #OK
2798            sigDict[phfx+'Mustrain;i'] =  2.*Mgam**2*(1.-parmDict[phfx+'Mustrain;mx'])**2/(ateln2*parmDict[phfx+'Mustrain;i'])       
2799        elif calcControls[phfx+'MustrainType'] == 'uniaxial':
2800            H = np.array(refl[:3])
2801            P = np.array(calcControls[phfx+'MustrainAxis'])
2802            cosP,sinP = G2lat.CosSinAngle(H,P,G)
2803            Si = parmDict[phfx+'Mustrain;i']
2804            Sa = parmDict[phfx+'Mustrain;a']
2805            gami = 1.e-6*parmDict[hfx+'difC']*refl[4+im]*Si*Sa
2806            sqtrm = np.sqrt((Si*cosP)**2+(Sa*sinP)**2)
2807            Mgam = gami/sqtrm
2808            dsi = -gami*Si*cosP**2/sqtrm**3
2809            dsa = -gami*Sa*sinP**2/sqtrm**3
2810            gamDict[phfx+'Mustrain;i'] = (Mgam/Si+dsi)*parmDict[phfx+'Mustrain;mx']
2811            gamDict[phfx+'Mustrain;a'] = (Mgam/Sa+dsa)*parmDict[phfx+'Mustrain;mx']
2812            sigDict[phfx+'Mustrain;i'] = 2*(Mgam/Si+dsi)*Mgam*(1.-parmDict[phfx+'Mustrain;mx'])**2/ateln2
2813            sigDict[phfx+'Mustrain;a'] = 2*(Mgam/Sa+dsa)*Mgam*(1.-parmDict[phfx+'Mustrain;mx'])**2/ateln2       
2814        else:       #generalized - P.W. Stephens model OK
2815            Strms = G2spc.MustrainCoeff(refl[:3],SGData)
2816            const = 1.e-6*parmDict[hfx+'difC']*refl[4+im]**3
2817            Sum = 0
2818            for i,strm in enumerate(Strms):
2819                Sum += parmDict[phfx+'Mustrain;'+str(i)]*strm
2820                gamDict[phfx+'Mustrain;'+str(i)] = strm*parmDict[phfx+'Mustrain;mx']/2.
2821                sigDict[phfx+'Mustrain;'+str(i)] = strm*(1.-parmDict[phfx+'Mustrain;mx'])**2
2822            Mgam = const*np.sqrt(Sum)
2823            for i in range(len(Strms)):
2824                gamDict[phfx+'Mustrain;'+str(i)] *= Mgam/Sum
2825                sigDict[phfx+'Mustrain;'+str(i)] *= const**2/ateln2       
2826        gamDict[phfx+'Mustrain;mx'] = Mgam
2827        sigDict[phfx+'Mustrain;mx'] = -2.*Mgam**2*(1.-parmDict[phfx+'Mustrain;mx'])/ateln2
2828       
2829    return sigDict,gamDict
2830       
2831def GetReflPos(refl,im,wave,A,pfx,hfx,calcControls,parmDict):
2832    'Needs a doc string'
2833    if im:
2834        h,k,l,m = refl[:4]
2835        vec = np.array([parmDict[pfx+'mV0'],parmDict[pfx+'mV1'],parmDict[pfx+'mV2']])
2836        d = 1./np.sqrt(G2lat.calc_rDsqSS(np.array([h,k,l,m]),A,vec))
2837    else:
2838        h,k,l = refl[:3]
2839        d = 1./np.sqrt(G2lat.calc_rDsq(np.array([h,k,l]),A))
2840    refl[4+im] = d
2841    if 'C' in calcControls[hfx+'histType']:
2842        pos = 2.0*asind(wave/(2.0*d))+parmDict[hfx+'Zero']
2843        const = 9.e-2/(np.pi*parmDict[hfx+'Gonio. radius'])                  #shifts in microns
2844        if 'Bragg' in calcControls[hfx+'instType']:
2845            pos -= const*(4.*parmDict[hfx+'Shift']*cosd(pos/2.0)+ \
2846                parmDict[hfx+'Transparency']*sind(pos)*100.0)            #trans(=1/mueff) in cm
2847        else:               #Debye-Scherrer - simple but maybe not right
2848            pos -= const*(parmDict[hfx+'DisplaceX']*cosd(pos)+parmDict[hfx+'DisplaceY']*sind(pos))
2849    elif 'T' in calcControls[hfx+'histType']:
2850        pos = parmDict[hfx+'difC']*d+parmDict[hfx+'difA']*d**2+parmDict[hfx+'difB']/d+parmDict[hfx+'Zero']
2851        #do I need sample position effects - maybe?
2852    return pos
2853
2854def GetReflPosDerv(refl,im,wave,A,pfx,hfx,calcControls,parmDict):
2855    'Needs a doc string'
2856    dpr = 180./np.pi
2857    if im:
2858        h,k,l,m = refl[:4]
2859        vec = np.array([parmDict[pfx+'mV0'],parmDict[pfx+'mV1'],parmDict[pfx+'mV2']])
2860        dstsq = G2lat.calc_rDsqSS(np.array([h,k,l,m]),A,vec)
2861        h,k,l = [h+m*vec[0],k+m*vec[1],l+m*vec[2]]          #do proj of hklm to hkl so dPdA & dPdV come out right
2862    else:
2863        m = 0
2864        h,k,l = refl[:3]       
2865        dstsq = G2lat.calc_rDsq(np.array([h,k,l]),A)
2866    dst = np.sqrt(dstsq)
2867    dsp = 1./dst
2868    if 'C' in calcControls[hfx+'histType']:
2869        pos = refl[5+im]-parmDict[hfx+'Zero']
2870        const = dpr/np.sqrt(1.0-wave**2*dstsq/4.0)
2871        dpdw = const*dst
2872        dpdA = np.array([h**2,k**2,l**2,h*k,h*l,k*l])*const*wave/(2.0*dst)
2873        dpdZ = 1.0
2874        dpdV = np.array([2.*h*A[0]+k*A[3]+l*A[4],2*k*A[1]+h*A[3]+l*A[5],
2875            2*l*A[2]+h*A[4]+k*A[5]])*m*const*wave/(2.0*dst)
2876        shft = 9.e-2/(np.pi*parmDict[hfx+'Gonio. radius'])                  #shifts in microns
2877        if 'Bragg' in calcControls[hfx+'instType']:
2878            dpdSh = -4.*shft*cosd(pos/2.0)
2879            dpdTr = -shft*sind(pos)*100.0
2880            return dpdA,dpdw,dpdZ,dpdSh,dpdTr,0.,0.,dpdV
2881        else:               #Debye-Scherrer - simple but maybe not right
2882            dpdXd = -shft*cosd(pos)
2883            dpdYd = -shft*sind(pos)
2884            return dpdA,dpdw,dpdZ,0.,0.,dpdXd,dpdYd,dpdV
2885    elif 'T' in calcControls[hfx+'histType']:
2886        dpdA = -np.array([h**2,k**2,l**2,h*k,h*l,k*l])*parmDict[hfx+'difC']*dsp**3/2.
2887        dpdZ = 1.0
2888        dpdDC = dsp
2889        dpdDA = dsp**2
2890        dpdDB = 1./dsp
2891        dpdV = np.array([2.*h*A[0]+k*A[3]+l*A[4],2*k*A[1]+h*A[3]+l*A[5],
2892            2*l*A[2]+h*A[4]+k*A[5]])*m*parmDict[hfx+'difC']*dsp**3/2.
2893        return dpdA,dpdZ,dpdDC,dpdDA,dpdDB,dpdV
2894           
2895def GetHStrainShift(refl,im,SGData,phfx,hfx,calcControls,parmDict):
2896    'Needs a doc string'
2897    laue = SGData['SGLaue']
2898    uniq = SGData['SGUniq']
2899    h,k,l = refl[:3]
2900    if laue in ['m3','m3m']:
2901        Dij = parmDict[phfx+'D11']*(h**2+k**2+l**2)+ \
2902            refl[4+im]**2*parmDict[phfx+'eA']*((h*k)**2+(h*l)**2+(k*l)**2)/(h**2+k**2+l**2)**2
2903    elif laue in ['6/m','6/mmm','3m1','31m','3']:
2904        Dij = parmDict[phfx+'D11']*(h**2+k**2+h*k)+parmDict[phfx+'D33']*l**2
2905    elif laue in ['3R','3mR']:
2906        Dij = parmDict[phfx+'D11']*(h**2+k**2+l**2)+parmDict[phfx+'D12']*(h*k+h*l+k*l)
2907    elif laue in ['4/m','4/mmm']:
2908        Dij = parmDict[phfx+'D11']*(h**2+k**2)+parmDict[phfx+'D33']*l**2
2909    elif laue in ['mmm']:
2910        Dij = parmDict[phfx+'D11']*h**2+parmDict[phfx+'D22']*k**2+parmDict[phfx+'D33']*l**2
2911    elif laue in ['2/m']:
2912        Dij = parmDict[phfx+'D11']*h**2+parmDict[phfx+'D22']*k**2+parmDict[phfx+'D33']*l**2
2913        if uniq == 'a':
2914            Dij += parmDict[phfx+'D23']*k*l
2915        elif uniq == 'b':
2916            Dij += parmDict[phfx+'D13']*h*l
2917        elif uniq == 'c':
2918            Dij += parmDict[phfx+'D12']*h*k
2919    else:
2920        Dij = parmDict[phfx+'D11']*h**2+parmDict[phfx+'D22']*k**2+parmDict[phfx+'D33']*l**2+ \
2921            parmDict[phfx+'D12']*h*k+parmDict[phfx+'D13']*h*l+parmDict[phfx+'D23']*k*l
2922    if 'C' in calcControls[hfx+'histType']:
2923        return -180.*Dij*refl[4+im]**2*tand(refl[5+im]/2.0)/np.pi
2924    else:
2925        return -Dij*parmDict[hfx+'difC']*refl[4+im]**2/2.
2926           
2927def GetHStrainShiftDerv(refl,im,SGData,phfx,hfx,calcControls,parmDict):
2928    'Needs a doc string'
2929    laue = SGData['SGLaue']
2930    uniq = SGData['SGUniq']
2931    h,k,l = refl[:3]
2932    if laue in ['m3','m3m']:
2933        dDijDict = {phfx+'D11':h**2+k**2+l**2,
2934            phfx+'eA':refl[4+im]**2*((h*k)**2+(h*l)**2+(k*l)**2)/(h**2+k**2+l**2)**2}
2935    elif laue in ['6/m','6/mmm','3m1','31m','3']:
2936        dDijDict = {phfx+'D11':h**2+k**2+h*k,phfx+'D33':l**2}
2937    elif laue in ['3R','3mR']:
2938        dDijDict = {phfx+'D11':h**2+k**2+l**2,phfx+'D12':h*k+h*l+k*l}
2939    elif laue in ['4/m','4/mmm']:
2940        dDijDict = {phfx+'D11':h**2+k**2,phfx+'D33':l**2}
2941    elif laue in ['mmm']:
2942        dDijDict = {phfx+'D11':h**2,phfx+'D22':k**2,phfx+'D33':l**2}
2943    elif laue in ['2/m']:
2944        dDijDict = {phfx+'D11':h**2,phfx+'D22':k**2,phfx+'D33':l**2}
2945        if uniq == 'a':
2946            dDijDict[phfx+'D23'] = k*l
2947        elif uniq == 'b':
2948            dDijDict[phfx+'D13'] = h*l
2949        elif uniq == 'c':
2950            dDijDict[phfx+'D12'] = h*k
2951    else:
2952        dDijDict = {phfx+'D11':h**2,phfx+'D22':k**2,phfx+'D33':l**2,
2953            phfx+'D12':h*k,phfx+'D13':h*l,phfx+'D23':k*l}
2954    if 'C' in calcControls[hfx+'histType']:
2955        for item in dDijDict:
2956            dDijDict[item] *= 180.0*refl[4+im]**2*tand(refl[5+im]/2.0)/np.pi
2957    else:
2958        for item in dDijDict:
2959            dDijDict[item] *= -parmDict[hfx+'difC']*refl[4+im]**3/2.
2960    return dDijDict
2961   
2962def GetDij(phfx,SGData,parmDict):
2963    HSvals = [parmDict[phfx+name] for name in G2spc.HStrainNames(SGData)]
2964    return G2spc.HStrainVals(HSvals,SGData)
2965               
2966def GetFobsSq(Histograms,Phases,parmDict,calcControls):
2967    '''Compute the observed structure factors for Powder histograms and store in reflection array
2968    Multiprocessing support added
2969    '''
2970    if GSASIIpath.GetConfigValue('Show_timing',False):
2971        starttime = time.time() #; print 'start GetFobsSq'
2972    histoList = list(Histograms.keys())
2973    histoList.sort()
2974    Ka2 = shl = lamRatio = kRatio = None
2975    for histogram in histoList:
2976        if 'PWDR' in histogram[:4]:
2977            Histogram = Histograms[histogram]
2978            hId = Histogram['hId']
2979            hfx = ':%d:'%(hId)
2980            Limits = calcControls[hfx+'Limits']
2981            if 'C' in calcControls[hfx+'histType']:
2982                shl = max(parmDict[hfx+'SH/L'],0.0005)
2983                Ka2 = False
2984                kRatio = 0.0
2985                if hfx+'Lam1' in list(parmDict.keys()):
2986                    Ka2 = True
2987                    lamRatio = 360*(parmDict[hfx+'Lam2']-parmDict[hfx+'Lam1'])/(np.pi*parmDict[hfx+'Lam1'])
2988                    kRatio = parmDict[hfx+'I(L2)/I(L1)']
2989            x,y,w,yc,yb,yd = Histogram['Data']
2990            xMask = ma.getmaskarray(x)
2991            xB = np.searchsorted(x,Limits[0])
2992            xF = np.searchsorted(x,Limits[1])
2993            ymb = np.array(y-yb)
2994            ymb = np.where(ymb,ymb,1.0)
2995            ycmb = np.array(yc-yb)
2996            ratio = 1./np.where(ycmb,ycmb/ymb,1.e10)         
2997            refLists = Histogram['Reflection Lists']
2998            for phase in refLists:
2999                if phase not in Phases:     #skips deleted or renamed phases silently!
3000                    continue
3001                Phase = Phases[phase]
3002                im = 0
3003                if Phase['General'].get('Modulated',False):
3004                    im = 1
3005                pId = Phase['pId']
3006                phfx = '%d:%d:'%(pId,hId)
3007                refDict = refLists[phase]
3008                sumFo = 0.0
3009                sumdF = 0.0
3010                sumFosq = 0.0
3011                sumdFsq = 0.0
3012                sumInt = 0.0
3013                nExcl = 0
3014                # test to see if we are using multiprocessing below
3015                useMP,ncores = G2mp.InitMP()
3016                if len(refDict['RefList']) < 100: useMP = False       
3017                if useMP: # multiprocessing: create a set of initialized Python processes
3018                    MPpool = mp.Pool(G2mp.ncores,G2mp.InitFobsSqGlobals,
3019                                    [x,ratio,shl,xB,xF,im,lamRatio,kRatio,xMask,Ka2])
3020                    profArgs = [[] for i in range(G2mp.ncores)]
3021                else:
3022                    G2mp.InitFobsSqGlobals(x,ratio,shl,xB,xF,im,lamRatio,kRatio,xMask,Ka2)
3023                if 'C' in calcControls[hfx+'histType']:
3024                    # are we multiprocessing?
3025                    for iref,refl in enumerate(refDict['RefList']):
3026                        if useMP: 
3027                            profArgs[iref%G2mp.ncores].append((refl,iref))
3028                        else:
3029                            icod= G2mp.ComputeFobsSqCW(refl,iref)
3030                            if type(icod) is tuple:
3031                                refl[8+im] = icod[0]
3032                                sumInt += icod[1]
3033                                if parmDict[phfx+'LeBail']: refl[9+im] = refl[8+im]
3034                            elif icod == -1:
3035                                refl[3+im] *= -1
3036                                nExcl += 1
3037                            elif icod == -2:
3038                                break
3039                    if useMP:
3040                        for sInt,resList in MPpool.imap_unordered(G2mp.ComputeFobsSqCWbatch,profArgs):
3041                            sumInt += sInt
3042                            for refl8im,irefl in resList:
3043                                if refl8im is None:
3044                                    refDict['RefList'][irefl][3+im] *= -1
3045                                    nExcl += 1
3046                                else:
3047                                    refDict['RefList'][irefl][8+im] = refl8im
3048                                    if parmDict[phfx+'LeBail']:
3049                                        refDict['RefList'][irefl][9+im] = refDict['RefList'][irefl][8+im]
3050                elif 'T' in calcControls[hfx+'histType']:
3051                    for iref,refl in enumerate(refDict['RefList']):
3052                        if useMP: 
3053                            profArgs[iref%G2mp.ncores].append((refl,iref))
3054                        else:
3055                            icod= G2mp.ComputeFobsSqTOF(refl,iref)
3056                            if type(icod) is tuple:
3057                                refl[8+im] = icod[0]
3058                                sumInt += icod[1]
3059                                if parmDict[phfx+'LeBail']: refl[9+im] = refl[8+im]
3060                            elif icod == -1:
3061                                refl[3+im] *= -1
3062                                nExcl += 1
3063                            elif icod == -2:
3064                                break
3065                    if useMP:
3066                        for sInt,resList in MPpool.imap_unordered(G2mp.ComputeFobsSqTOFbatch,profArgs):
3067                            sumInt += sInt
3068                            for refl8im,irefl in resList:
3069                                if refl8im is None:
3070                                    refDict['RefList'][irefl][3+im] *= -1
3071                                    nExcl += 1
3072                                else:
3073                                    refDict['RefList'][irefl][8+im] = refl8im
3074                                    if parmDict[phfx+'LeBail']:
3075                                        refDict['RefList'][irefl][9+im] = refDict['RefList'][irefl][8+im]
3076                if useMP: MPpool.terminate()
3077                sumFo = 0.0
3078                sumdF = 0.0
3079                sumFosq = 0.0
3080                sumdFsq = 0.0
3081                for iref,refl in enumerate(refDict['RefList']):
3082                    Fo = np.sqrt(np.abs(refl[8+im]))
3083                    Fc = np.sqrt(np.abs(refl[9]+im))
3084                    sumFo += Fo
3085                    sumFosq += refl[8+im]**2
3086                    sumdF += np.abs(Fo-Fc)
3087                    sumdFsq += (refl[8+im]-refl[9+im])**2
3088                if sumFo:
3089                    Histogram['Residuals'][phfx+'Rf'] = min(100.,(sumdF/sumFo)*100.)
3090                    Histogram['Residuals'][phfx+'Rf^2'] = min(100.,np.sqrt(sumdFsq/sumFosq)*100.)
3091                else:
3092                    Histogram['Residuals'][phfx+'Rf'] = 100.
3093                    Histogram['Residuals'][phfx+'Rf^2'] = 100.
3094                Histogram['Residuals'][phfx+'sumInt'] = sumInt
3095                Histogram['Residuals'][phfx+'Nref'] = len(refDict['RefList'])-nExcl
3096                Histogram['Residuals']['hId'] = hId
3097        elif 'HKLF' in histogram[:4]:
3098            Histogram = Histograms[histogram]
3099            Histogram['Residuals']['hId'] = Histograms[histogram]['hId']
3100    if GSASIIpath.GetConfigValue('Show_timing',False):
3101        print ('GetFobsSq t=',time.time()-starttime)
3102               
3103def getPowderProfile(parmDict,x,varylist,Histogram,Phases,calcControls,pawleyLookup):
3104    'Computes the powder pattern for a histogram based on contributions from all used phases'
3105    if GSASIIpath.GetConfigValue('Show_timing',False): starttime = time.time()
3106   
3107    def GetReflSigGamCW(refl,im,wave,G,GB,phfx,calcControls,parmDict):
3108        U = parmDict[hfx+'U']
3109        V = parmDict[hfx+'V']
3110        W = parmDict[hfx+'W']
3111        X = parmDict[hfx+'X']
3112        Y = parmDict[hfx+'Y']
3113        Z = parmDict[hfx+'Z']
3114        tanPos = tand(refl[5+im]/2.0)
3115        Ssig,Sgam = GetSampleSigGam(refl,im,wave,G,GB,SGData,hfx,phfx,calcControls,parmDict)
3116        sig = U*tanPos**2+V*tanPos+W+Ssig     #save peak sigma
3117        sig = max(0.001,sig)
3118        gam = X/cosd(refl[5+im]/2.0)+Y*tanPos+Sgam+Z     #save peak gamma
3119        gam = max(0.001,gam)
3120        return sig,gam
3121               
3122    def GetReflSigGamTOF(refl,im,G,GB,phfx,calcControls,parmDict):
3123        sig = parmDict[hfx+'sig-0']+parmDict[hfx+'sig-1']*refl[4+im]**2+   \
3124            parmDict[hfx+'sig-2']*refl[4+im]**4+parmDict[hfx+'sig-q']*refl[4+im]
3125        gam = parmDict[hfx+'X']*refl[4+im]+parmDict[hfx+'Y']*refl[4+im]**2+parmDict[hfx+'Z']
3126        Ssig,Sgam = GetSampleSigGam(refl,im,0.0,G,GB,SGData,hfx,phfx,calcControls,parmDict)
3127        sig += Ssig
3128        gam += Sgam
3129        return sig,gam
3130       
3131    def GetReflAlpBet(refl,im,hfx,parmDict):
3132        alp = parmDict[hfx+'alpha']/refl[4+im]
3133        bet = parmDict[hfx+'beta-0']+parmDict[hfx+'beta-1']/refl[4+im]**4+parmDict[hfx+'beta-q']/refl[4+im]**2
3134        return alp,bet
3135       
3136    hId = Histogram['hId']
3137    hfx = ':%d:'%(hId)
3138    bakType = calcControls[hfx+'bakType']
3139    yb,Histogram['sumBk'] = G2pwd.getBackground(hfx,parmDict,bakType,calcControls[hfx+'histType'],x)
3140    yc = np.zeros_like(yb)
3141    cw = np.diff(ma.getdata(x))
3142    cw = np.append(cw,cw[-1])
3143       
3144    if 'C' in calcControls[hfx+'histType']:   
3145        shl = max(parmDict[hfx+'SH/L'],0.002)
3146        Ka2 = False
3147        if hfx+'Lam1' in (parmDict.keys()):
3148            wave = parmDict[hfx+'Lam1']
3149            Ka2 = True
3150            lamRatio = 360*(parmDict[hfx+'Lam2']-parmDict[hfx+'Lam1'])/(np.pi*parmDict[hfx+'Lam1'])
3151            kRatio = parmDict[hfx+'I(L2)/I(L1)']
3152        else:
3153            wave = parmDict[hfx+'Lam']
3154    else:
3155        shl = 0.
3156    for phase in Histogram['Reflection Lists']:
3157        refDict = Histogram['Reflection Lists'][phase]
3158        if phase not in Phases:     #skips deleted or renamed phases silently!
3159            continue
3160        Phase = Phases[phase]
3161        pId = Phase['pId']
3162        pfx = '%d::'%(pId)
3163        phfx = '%d:%d:'%(pId,hId)
3164        hfx = ':%d:'%(hId)
3165        SGData = Phase['General']['SGData']
3166        SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
3167        im = 0
3168        if Phase['General'].get('Modulated',False):
3169            SSGData = Phase['General']['SSGData']
3170            im = 1  #offset in SS reflection list
3171            #??
3172        Dij = GetDij(phfx,SGData,parmDict)
3173        A = [parmDict[pfx+'A%d'%(i)]+Dij[i] for i in range(6)]  #TODO: need to do someting if Dij << 0.
3174        G,g = G2lat.A2Gmat(A)       #recip & real metric tensors
3175        if np.any(np.diag(G)<0.) or np.any(np.isnan(A)):
3176            raise G2obj.G2Exception('invalid metric tensor \n cell/Dij refinement not advised')
3177        GA,GB = G2lat.Gmat2AB(G)    #Orthogonalization matricies
3178        Vst = np.sqrt(nl.det(G))    #V*
3179        if not Phase['General'].get('doPawley') and not parmDict[phfx+'LeBail']:
3180            if im:
3181                SStructureFactor(refDict,G,hfx,pfx,SGData,SSGData,calcControls,parmDict)
3182            elif parmDict[pfx+'isMag'] and 'N' in calcControls[hfx+'histType']:
3183                MagStructureFactor2(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
3184            else:
3185                StructureFactor2(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
3186        badPeak = False
3187        # test to see if we are using multiprocessing here
3188        useMP,ncores = G2mp.InitMP()
3189        if len(refDict['RefList']) < 100: useMP = False       
3190        if useMP: # multiprocessing: create a set of initialized Python processes
3191            MPpool = mp.Pool(ncores,G2mp.InitPwdrProfGlobals,[im,shl,x])
3192            profArgs = [[] for i in range(ncores)]
3193        if 'C' in calcControls[hfx+'histType']:
3194            for iref,refl in enumerate(refDict['RefList']):
3195                if im:
3196                    h,k,l,m = refl[:4]
3197                else:
3198                    h,k,l = refl[:3]
3199                Uniq = np.inner(refl[:3],SGMT)
3200                refl[5+im] = GetReflPos(refl,im,wave,A,pfx,hfx,calcControls,parmDict)         #corrected reflection position
3201                Lorenz = 1./(2.*sind(refl[5+im]/2.)**2*cosd(refl[5+im]/2.))           #Lorentz correction
3202                refl[6+im:8+im] = GetReflSigGamCW(refl,im,wave,G,GB,phfx,calcControls,parmDict)    #peak sig & gam
3203                refl[11+im:15+im] = GetIntensityCorr(refl,im,Uniq,G,g,pfx,phfx,hfx,SGData,calcControls,parmDict)
3204                refl[11+im] *= Vst*Lorenz
3205                 
3206                if Phase['General'].get('doPawley'):
3207                    try:
3208                        if im:
3209                            pInd = pfx+'PWLref:%d'%(pawleyLookup[pfx+'%d,%d,%d,%d'%(h,k,l,m)])
3210                        else:
3211                            pInd = pfx+'PWLref:%d'%(pawleyLookup[pfx+'%d,%d,%d'%(h,k,l)])
3212                        refl[9+im] = parmDict[pInd]
3213                    except KeyError:
3214#                        print ' ***Error %d,%d,%d missing from Pawley reflection list ***'%(h,k,l)
3215                        continue
3216                Wd,fmin,fmax = G2pwd.getWidthsCW(refl[5+im],refl[6+im],refl[7+im],shl)
3217                iBeg = np.searchsorted(x,refl[5+im]-fmin)
3218                iFin = np.searchsorted(x,refl[5+im]+fmax)
3219                if not iBeg+iFin:       #peak below low limit - skip peak
3220                    continue
3221                elif not iBeg-iFin:     #peak above high limit - done
3222                    break
3223                elif iBeg > iFin:   #bad peak coeff - skip
3224                    badPeak = True
3225                    continue
3226                if useMP:
3227                    profArgs[iref%ncores].append((refl[5+im],refl,iBeg,iFin,1.))
3228                else:
3229                    yc[iBeg:iFin] += refl[11+im]*refl[9+im]*G2pwd.getFCJVoigt3(refl[5+im],refl[6+im],refl[7+im],shl,ma.getdata(x[iBeg:iFin]))    #>90% of time spent here
3230                if Ka2:
3231                    pos2 = refl[5+im]+lamRatio*tand(refl[5+im]/2.0)       # + 360/pi * Dlam/lam * tan(th)
3232                    Wd,fmin,fmax = G2pwd.getWidthsCW(pos2,refl[6+im],refl[7+im],shl)
3233                    iBeg = np.searchsorted(x,pos2-fmin)
3234                    iFin = np.searchsorted(x,pos2+fmax)
3235                    if not iBeg+iFin:       #peak below low limit - skip peak
3236                        continue
3237                    elif not iBeg-iFin:     #peak above high limit - done
3238                        return yc,yb
3239                    elif iBeg > iFin:   #bad peak coeff - skip
3240                        continue
3241                    if useMP:
3242                        profArgs[iref%ncores].append((pos2,refl,iBeg,iFin,kRatio))
3243                    else:
3244                        yc[iBeg:iFin] += refl[11+im]*refl[9+im]*kRatio*G2pwd.getFCJVoigt3(pos2,refl[6+im],refl[7+im],shl,ma.getdata(x[iBeg:iFin]))        #and here
3245        elif 'T' in calcControls[hfx+'histType']:
3246            for iref,refl in enumerate(refDict['RefList']):
3247                if im:
3248                    h,k,l,m = refl[:4]
3249                else:
3250                    h,k,l = refl[:3]
3251                Uniq = np.inner(refl[:3],SGMT)
3252                refl[5+im] = GetReflPos(refl,im,0.0,A,pfx,hfx,calcControls,parmDict)         #corrected reflection position - #TODO - what about tabluated offset?
3253                Lorenz = sind(abs(parmDict[hfx+'2-theta'])/2)*refl[4+im]**4                                                #TOF Lorentz correction
3254#                refl[5+im] += GetHStrainShift(refl,im,SGData,phfx,hfx,calcControls,parmDict)               #apply hydrostatic strain shift
3255                refl[6+im:8+im] = GetReflSigGamTOF(refl,im,G,GB,phfx,calcControls,parmDict)    #peak sig & gam
3256                refl[12+im:14+im] = GetReflAlpBet(refl,im,hfx,parmDict)             #TODO - skip if alp, bet tabulated?
3257                refl[11+im],refl[15+im],refl[16+im],refl[17+im] = GetIntensityCorr(refl,im,Uniq,G,g,pfx,phfx,hfx,SGData,calcControls,parmDict)
3258                refl[11+im] *= Vst*Lorenz
3259                if Phase['General'].get('doPawley'):
3260                    try:
3261                        if im:
3262                            pInd =pfx+'PWLref:%d'%(pawleyLookup[pfx+'%d,%d,%d,%d'%(h,k,l,m)])
3263                        else:
3264                            pInd =pfx+'PWLref:%d'%(pawleyLookup[pfx+'%d,%d,%d'%(h,k,l)])
3265                        refl[9+im] = parmDict[pInd]
3266                    except KeyError:
3267#                        print ' ***Error %d,%d,%d missing from Pawley reflection list ***'%(h,k,l)
3268                        continue
3269                Wd,fmin,fmax = G2pwd.getWidthsTOF(refl[5+im],refl[12+im],refl[13+im],refl[6+im],refl[7+im])
3270                iBeg = np.searchsorted(x,refl[5+im]-fmin)
3271                iFin = np.searchsorted(x,refl[5+im]+fmax)
3272                if not iBeg+iFin:       #peak below low limit - skip peak
3273                    continue
3274                elif not iBeg-iFin:     #peak above high limit - done
3275                    break
3276                elif iBeg > iFin:   #bad peak coeff - skip
3277                    badPeak = True
3278                    continue
3279                if useMP:
3280                    profArgs[iref%ncores].append((refl[5+im],refl,iBeg,iFin))
3281                else:
3282                    yc[iBeg:iFin] += refl[11+im]*refl[9+im]*G2pwd.getEpsVoigt(refl[5+im],refl[12+im],refl[13+im],refl[6+im],refl[7+im],ma.getdata(x[iBeg:iFin]))/cw[iBeg:iFin]
3283#        print 'profile calc time: %.3fs'%(time.time()-time0)
3284        if useMP and 'C' in calcControls[hfx+'histType']:
3285            for y in MPpool.imap_unordered(G2mp.ComputePwdrProfCW,profArgs):
3286                yc += y
3287            MPpool.terminate()
3288        elif useMP:
3289            for y in MPpool.imap_unordered(G2mp.ComputePwdrProfTOF,profArgs):
3290                yc += y
3291            MPpool.terminate()
3292    if badPeak:
3293        print ('ouch #4 bad profile coefficients yield negative peak width; some reflections skipped')
3294    if GSASIIpath.GetConfigValue('Show_timing',False):
3295        print ('getPowderProfile t=%.3f'%(time.time()-starttime))
3296    return yc,yb
3297   
3298def getPowderProfileDervMP(args):
3299    '''Computes the derivatives of the computed powder pattern with respect to all
3300    refined parameters.
3301    Multiprocessing version.
3302    '''
3303    import pytexture as ptx
3304    ptx.pyqlmninit()            #initialize fortran arrays for spherical harmonics for each processor
3305    parmDict,x,varylist,Histogram,Phases,rigidbodyDict,calcControls,pawleyLookup,dependentVars = args[:9]
3306    prc=0
3307    tprc=1
3308    if len(args) >= 10: prc=args[9]
3309    if len(args) >= 11: tprc=args[10]
3310    def cellVaryDerv(pfx,SGData,dpdA): 
3311        if SGData['SGLaue'] in ['-1',]:
3312            return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],
3313                [pfx+'A3',dpdA[3]],[pfx+'A4',dpdA[4]],[pfx+'A5',dpdA[5]]]
3314        elif SGData['SGLaue'] in ['2/m',]:
3315            if SGData['SGUniq'] == 'a':
3316                return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],[pfx+'A5',dpdA[5]]]
3317            elif SGData['SGUniq'] == 'b':
3318                return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],[pfx+'A4',dpdA[4]]]
3319            else:
3320                return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],[pfx+'A3',dpdA[3]]]
3321        elif SGData['SGLaue'] in ['mmm',]:
3322            return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]]]
3323        elif SGData['SGLaue'] in ['4/m','4/mmm']:
3324            return [[pfx+'A0',dpdA[0]],[pfx+'A2',dpdA[2]]]
3325        elif SGData['SGLaue'] in ['6/m','6/mmm','3m1', '31m', '3']:
3326            return [[pfx+