Changeset 3414


Ignore:
Timestamp:
May 30, 2018 2:29:54 PM (3 years ago)
Author:
vondreele
Message:

correct Uij & sin/cosUij derivatives for i!=j; all needed *2.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/GSASIIstrMath.py

    r3383 r3414  
    923923        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
    924924        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
    925         dFdvDict[pfx+'AU12:'+str(i)] = dFdua.T[3][i]
    926         dFdvDict[pfx+'AU13:'+str(i)] = dFdua.T[4][i]
    927         dFdvDict[pfx+'AU23:'+str(i)] = dFdua.T[5][i]
     925        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
     926        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
     927        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
    928928    dFdvDict[phfx+'Flack'] = 4.*dFdfl.T
    929929    dFdvDict[phfx+'BabA'] = dFdbab.T[0]
     
    10751075    :returns: dict dFdvDict: dictionary of derivatives
    10761076    '''
    1077     #TODO: fix mag math - moments parallel to crystal axes
    10781077    g = nl.inv(G)
    10791078    ast = np.sqrt(np.diag(G))
     
    10991098    dMdm = np.inner(Gdata.T,Ginv).T/Mag
    11001099    Gdata = np.inner(Gdata.T,SGMT).T            #apply sym. ops.
    1101     dG = np.inner(np.eye(3),SGMT).T
    11021100    if SGData['SGInv'] and not SGData['SGFixed']:
    11031101        Gdata = np.hstack((Gdata,-Gdata))       #inversion if any
    1104         dG = np.hstack((dG,-dG))
    11051102    Gdata = np.hstack([Gdata for icen in range(Ncen)])        #dup over cell centering
    1106     dG = np.hstack([dG for icen in range(Ncen)])
    11071103    Gdata = SGData['MagMom'][nxs,:,nxs]*Gdata   #flip vectors according to spin flip
    11081104    Mag = np.tile(Mag[:,nxs],Nops).T  #make Mag same length as Gdata
    11091105    VGi = np.sqrt(nl.det(Ginv))
    11101106    Kdata = np.inner(Gdata.T,uAmat).T*VGi/Mag       #make unit vectors in Cartesian space
    1111     dG = np.inner(dG.T,uAmat).T*VGi
    11121107    dkdG = (np.inner(np.ones(3),uAmat)*VGi)[:,nxs,nxs]/Mag[nxs,:,:]
    11131108    dkdm = dkdG-Kdata*dMdm[:,nxs,:]/Mag[nxs,:,:]
     
    11241119#reflection processing begins here - big arrays!
    11251120    iBeg = 0
    1126     blkSize = 40       #no. of reflections in a block - optimized for speed
     1121    blkSize = 5       #no. of reflections in a block - optimized for speed
    11271122    while iBeg < nRef:
    11281123        iFin = min(iBeg+blkSize,nRef)
     
    11621157        HM = HM/np.sqrt(np.sum(HM**2,axis=0))               #unit cartesian vector for H
    11631158        eDotK = np.sum(HM[:,:,nxs,nxs]*Kdata[:,nxs,:,:],axis=0)
    1164         deDotK = HM.T[nxs,:,nxs,:]*dG.T[:,nxs,:,:]   #Mxyz,Nref,Nops
    11651159        Q = HM[:,:,nxs,nxs]*eDotK[nxs,:,:,:]-Kdata[:,nxs,:,:] #Mxyz,Nref,Nop,Natm = BPM in magstrfc.for OK
    1166         dqdk = np.sum(HM[:,:,nxs,nxs]*deDotK-dG.T[:,nxs,:,:],axis=3)     #Nref,Nops,Mxyyz
    1167         NQ = np.where(np.abs(Q)>0.,1./np.abs(Q),0.)     #this sort of works esp for 1 axis moments
    1168         dqdm = dqdk[:,:,:,nxs]*dkdm[:,nxs,:,:]
     1160        dqdk = np.array([np.outer(hm,hm)-np.eye(3) for hm in HM.T]).T     #Mxyz**2,Nref
     1161#        NQ = np.where(np.abs(Q)>0.,1./np.abs(Q),0.)     #this sort of works esp for 1 axis moments
     1162        NQ = np.sqrt(np.sum(Q*Q,axis=0))
     1163        NQ = np.where(NQ > 0.,1./NQ,0.)
     1164        dqdm = dqdk[:,:,:,nxs,nxs]*dkdm[:,nxs,nxs,:,:]   #Mxyz**2,Nref,Nops,Natms
    11691165        dmx = NQ*Q*dMdm[:,nxs,nxs,:]
    1170         dmx += NQ*dqdm*Mag[nxs,nxs,:,:]
     1166        dmx = dmx[nxs,:,:,:,:]+dqdm*Mag[nxs,nxs,nxs,:,:]
    11711167       
    11721168        fam = Q*TMcorr[nxs,:,nxs,:]*cosm[nxs,:,:,:]*Mag[nxs,nxs,:,:]    #Mxyz,Nref,Nop,Natm
     
    11791175        dfadfr = np.sum(fam/occ,axis=2)        #array(Mxyz,refBlk,nAtom) Fdata != 0 avoids /0. problem deriv OK
    11801176        dfadx = np.sum(twopi*Uniq[nxs,:,:,nxs,:]*famx[:,:,:,:,nxs],axis=2)          #deriv OK
    1181         dfadmx = np.sum(dmx*TMcorr[nxs,:,nxs,:]*cosm[nxs,:,:,:],axis=2)
     1177        dfadmx = np.sum(dmx*TMcorr[nxs,nxs,:,nxs,:]*cosm[nxs,nxs,:,:,:],axis=3)
    11821178        dfadui = np.sum(-SQfactor[:,nxs,nxs]*fam,axis=2) #array(Ops,refBlk,nAtoms)  deriv OK
    11831179        dfadua = np.sum(-Hij[nxs,:,:,nxs,:]*fam[:,:,:,:,nxs],axis=2)    #deriv OK? not U12 & U23 in sarc
     
    11851181        dfbdfr = np.sum(fbm/occ,axis=2)        #array(mxyz,refBlk,nAtom) Fdata != 0 avoids /0. problem
    11861182        dfbdx = np.sum(twopi*Uniq[nxs,:,:,nxs,:]*fbmx[:,:,:,:,nxs],axis=2)
    1187         dfbdmx = np.sum(dmx*TMcorr[nxs,:,nxs,:]*sinm[nxs,:,:,:],axis=2)
     1183        dfbdmx = np.sum(dmx*TMcorr[nxs,nxs,:,nxs,:]*sinm[nxs,nxs,:,:,:],axis=3)
    11881184        dfbdui = np.sum(-SQfactor[:,nxs,nxs]*fbm,axis=2) #array(Ops,refBlk,nAtoms)
    11891185        dfbdua = np.sum(-Hij[nxs,:,:,nxs,:]*fbm[:,:,:,:,nxs],axis=2)
     
    11911187        dFdfr[iBeg:iFin] = 2.*np.sum((fams[:,:,nxs]*dfadfr+fbms[:,:,nxs]*dfbdfr)*Mdata/Nops,axis=0) #ok
    11921188        dFdx[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs,nxs]*dfadx+fbms[:,:,nxs,nxs]*dfbdx,axis=0)         #ok
    1193         dFdMx[:,iBeg:iFin,:] = 2.*(fams[:,:,nxs]*dfadmx+fbms[:,:,nxs]*dfbdmx)                       #problems
     1189        dFdMx[:,iBeg:iFin,:] = 2.*np.sum(fams[:,:,nxs]*dfadmx+fbms[:,:,nxs]*dfbdmx,axis=0)/len(SGT)          #problems
    11941190        dFdui[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs]*dfadui+fbms[:,:,nxs]*dfbdui,axis=0)              #ok
    1195         dFdua[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs,nxs]*dfadua+fbms[:,:,nxs,nxs]*dfbdua,axis=0)      #problems U12 & U23 in sarc
     1191        dFdua[iBeg:iFin] = 2.*np.sum(fams[:,:,nxs,nxs]*dfadua+fbms[:,:,nxs,nxs]*dfbdua,axis=0)      #ok
    11961192        iBeg += blkSize
    11971193    print (' %d derivative time %.4f\r'%(nRef,time.time()-time0))
     
    12091205        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
    12101206        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
    1211         dFdvDict[pfx+'AU12:'+str(i)] = dFdua.T[3][i]
    1212         dFdvDict[pfx+'AU13:'+str(i)] = dFdua.T[4][i]
    1213         dFdvDict[pfx+'AU23:'+str(i)] = dFdua.T[5][i]
     1207        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
     1208        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
     1209        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
    12141210    return dFdvDict
    12151211       
     
    13691365        dFdvDict[pfx+'AU22:'+str(i)] = np.sum(dFdua.T[1][i]*TwinFr[:,nxs],axis=0)
    13701366        dFdvDict[pfx+'AU33:'+str(i)] = np.sum(dFdua.T[2][i]*TwinFr[:,nxs],axis=0)
    1371         dFdvDict[pfx+'AU12:'+str(i)] = np.sum(dFdua.T[3][i]*TwinFr[:,nxs],axis=0)
    1372         dFdvDict[pfx+'AU13:'+str(i)] = np.sum(dFdua.T[4][i]*TwinFr[:,nxs],axis=0)
    1373         dFdvDict[pfx+'AU23:'+str(i)] = np.sum(dFdua.T[5][i]*TwinFr[:,nxs],axis=0)
     1367        dFdvDict[pfx+'AU12:'+str(i)] = 2.*np.sum(dFdua.T[3][i]*TwinFr[:,nxs],axis=0)
     1368        dFdvDict[pfx+'AU13:'+str(i)] = 2.*np.sum(dFdua.T[4][i]*TwinFr[:,nxs],axis=0)
     1369        dFdvDict[pfx+'AU23:'+str(i)] = 2.*np.sum(dFdua.T[5][i]*TwinFr[:,nxs],axis=0)
    13741370    dFdvDict[phfx+'BabA'] = dFdbab.T[0]
    13751371    dFdvDict[phfx+'BabU'] = dFdbab.T[1]
     
    14161412        return
    14171413
    1418     if parmDict[pfx+'isMag']:       #TODO: fix the math - mag moments now along crystal axes
     1414    if parmDict[pfx+'isMag']:       #TODO: fix the math
    14191415        Mag = np.sqrt(np.sum(Gdata**2,axis=0))      #magnitude of moments for uniq atoms
    14201416        Gdata = np.where(Mag>0.,Gdata/Mag,0.)       #normalze mag. moments
     
    14931489        Tcorr = np.reshape(Tiso,Tuij.shape)*Tuij*Mdata*Fdata/Uniq.shape[1]  #refBlk x ops x atoms
    14941490
    1495         if 'N' in calcControls[hfx+'histType'] and parmDict[pfx+'isMag']:       #TODO: math here??
     1491        if 'N' in calcControls[hfx+'histType'] and parmDict[pfx+'isMag']:       #TODO: mag math here??
    14961492            MF = refDict['FF']['MF'][iBeg:iFin].T[Tindx].T   #Nref,Natm
    14971493            TMcorr = 0.539*(np.reshape(Tiso,Tuij.shape)*Tuij)[:,0,:]*Fdata*Mdata*MF/(2*Nops)     #Nref,Natm
     
    18681864        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
    18691865        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
    1870         dFdvDict[pfx+'AU12:'+str(i)] = dFdua.T[3][i]
    1871         dFdvDict[pfx+'AU13:'+str(i)] = dFdua.T[4][i]
    1872         dFdvDict[pfx+'AU23:'+str(i)] = dFdua.T[5][i]
     1866        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
     1867        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
     1868        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
    18731869        for j in range(FSSdata.shape[1]):        #loop over waves Fzero & Fwid?
    18741870            dFdvDict[pfx+'Fsin:'+str(i)+':'+str(j)] = dFdGf.T[0][j][i]
     
    18931889            dFdvDict[pfx+'U22sin:'+str(i)+':'+str(j)] = dFdGu.T[1][j][i]
    18941890            dFdvDict[pfx+'U33sin:'+str(i)+':'+str(j)] = dFdGu.T[2][j][i]
    1895             dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = dFdGu.T[3][j][i]
    1896             dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = dFdGu.T[4][j][i]
    1897             dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = dFdGu.T[5][j][i]
     1891            dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[3][j][i]
     1892            dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[4][j][i]
     1893            dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[5][j][i]
    18981894            dFdvDict[pfx+'U11cos:'+str(i)+':'+str(j)] = dFdGu.T[6][j][i]
    18991895            dFdvDict[pfx+'U22cos:'+str(i)+':'+str(j)] = dFdGu.T[7][j][i]
    19001896            dFdvDict[pfx+'U33cos:'+str(i)+':'+str(j)] = dFdGu.T[8][j][i]
    1901             dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = dFdGu.T[9][j][i]
    1902             dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = dFdGu.T[10][j][i]
    1903             dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = dFdGu.T[11][j][i]
     1897            dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[9][j][i]
     1898            dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[10][j][i]
     1899            dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[11][j][i]
    19041900           
    19051901#        GSASIIpath.IPyBreak()
     
    20922088        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
    20932089        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
    2094         dFdvDict[pfx+'AU12:'+str(i)] = dFdua.T[3][i]
    2095         dFdvDict[pfx+'AU13:'+str(i)] = dFdua.T[4][i]
    2096         dFdvDict[pfx+'AU23:'+str(i)] = dFdua.T[5][i]
     2090        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
     2091        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
     2092        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
    20972093        for j in range(FSSdata.shape[1]):        #loop over waves Fzero & Fwid?
    20982094            dFdvDict[pfx+'Fsin:'+str(i)+':'+str(j)] = dFdGf.T[0][j][i]
     
    21172113            dFdvDict[pfx+'U22sin:'+str(i)+':'+str(j)] = dFdGu.T[1][j][i]
    21182114            dFdvDict[pfx+'U33sin:'+str(i)+':'+str(j)] = dFdGu.T[2][j][i]
    2119             dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = dFdGu.T[3][j][i]
    2120             dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = dFdGu.T[4][j][i]
    2121             dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = dFdGu.T[5][j][i]
     2115            dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[3][j][i]
     2116            dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[4][j][i]
     2117            dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[5][j][i]
    21222118            dFdvDict[pfx+'U11cos:'+str(i)+':'+str(j)] = dFdGu.T[6][j][i]
    21232119            dFdvDict[pfx+'U22cos:'+str(i)+':'+str(j)] = dFdGu.T[7][j][i]
    21242120            dFdvDict[pfx+'U33cos:'+str(i)+':'+str(j)] = dFdGu.T[8][j][i]
    2125             dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = dFdGu.T[9][j][i]
    2126             dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = dFdGu.T[10][j][i]
    2127             dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = dFdGu.T[11][j][i]
     2121            dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[9][j][i]
     2122            dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[10][j][i]
     2123            dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[11][j][i]
    21282124           
    21292125#        GSASIIpath.IPyBreak()
     
    22952291        dFdvDict[pfx+'AU22:'+str(i)] = dFdua.T[1][i]
    22962292        dFdvDict[pfx+'AU33:'+str(i)] = dFdua.T[2][i]
    2297         dFdvDict[pfx+'AU12:'+str(i)] = dFdua.T[3][i]
    2298         dFdvDict[pfx+'AU13:'+str(i)] = dFdua.T[4][i]
    2299         dFdvDict[pfx+'AU23:'+str(i)] = dFdua.T[5][i]
     2293        dFdvDict[pfx+'AU12:'+str(i)] = 2.*dFdua.T[3][i]
     2294        dFdvDict[pfx+'AU13:'+str(i)] = 2.*dFdua.T[4][i]
     2295        dFdvDict[pfx+'AU23:'+str(i)] = 2.*dFdua.T[5][i]
    23002296        for j in range(FSSdata.shape[1]):        #loop over waves Fzero & Fwid?
    23012297            dFdvDict[pfx+'Fsin:'+str(i)+':'+str(j)] = dFdGf.T[0][j][i]
     
    23202316            dFdvDict[pfx+'U22sin:'+str(i)+':'+str(j)] = dFdGu.T[1][j][i]
    23212317            dFdvDict[pfx+'U33sin:'+str(i)+':'+str(j)] = dFdGu.T[2][j][i]
    2322             dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = dFdGu.T[3][j][i]
    2323             dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = dFdGu.T[4][j][i]
    2324             dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = dFdGu.T[5][j][i]
     2318            dFdvDict[pfx+'U12sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[3][j][i]
     2319            dFdvDict[pfx+'U13sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[4][j][i]
     2320            dFdvDict[pfx+'U23sin:'+str(i)+':'+str(j)] = 2.*dFdGu.T[5][j][i]
    23252321            dFdvDict[pfx+'U11cos:'+str(i)+':'+str(j)] = dFdGu.T[6][j][i]
    23262322            dFdvDict[pfx+'U22cos:'+str(i)+':'+str(j)] = dFdGu.T[7][j][i]
    23272323            dFdvDict[pfx+'U33cos:'+str(i)+':'+str(j)] = dFdGu.T[8][j][i]
    2328             dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = dFdGu.T[9][j][i]
    2329             dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = dFdGu.T[10][j][i]
    2330             dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = dFdGu.T[11][j][i]
     2324            dFdvDict[pfx+'U12cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[9][j][i]
     2325            dFdvDict[pfx+'U13cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[10][j][i]
     2326            dFdvDict[pfx+'U23cos:'+str(i)+':'+str(j)] = 2.*dFdGu.T[11][j][i]
    23312327           
    23322328#        GSASIIpath.IPyBreak()
     
    33953391    return yc,yb
    33963392   
    3397 # def getPowderProfileDerv(parmDict,x,varylist,Histogram,Phases,rigidbodyDict,calcControls,pawleyLookup,dependentVars):
    3398 #     '''Computes the derivatives of the computed powder pattern with respect to all
    3399 #     refined parameters
    3400 #     '''
    3401 #     #if GSASIIpath.GetConfigValue('debug'):
    3402 #     #    starttime = time.time()
    3403 #     #    print 'starting getPowderProfileDerv'
    3404    
    3405 #     def cellVaryDerv(pfx,SGData,dpdA):
    3406 #         if SGData['SGLaue'] in ['-1',]:
    3407 #             return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],
    3408 #                 [pfx+'A3',dpdA[3]],[pfx+'A4',dpdA[4]],[pfx+'A5',dpdA[5]]]
    3409 #         elif SGData['SGLaue'] in ['2/m',]:
    3410 #             if SGData['SGUniq'] == 'a':
    3411 #                 return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],[pfx+'A5',dpdA[5]]]
    3412 #             elif SGData['SGUniq'] == 'b':
    3413 #                 return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],[pfx+'A4',dpdA[4]]]
    3414 #             else:
    3415 #                 return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]],[pfx+'A3',dpdA[3]]]
    3416 #         elif SGData['SGLaue'] in ['mmm',]:
    3417 #             return [[pfx+'A0',dpdA[0]],[pfx+'A1',dpdA[1]],[pfx+'A2',dpdA[2]]]
    3418 #         elif SGData['SGLaue'] in ['4/m','4/mmm']:
    3419 #             return [[pfx+'A0',dpdA[0]],[pfx+'A2',dpdA[2]]]
    3420 #         elif SGData['SGLaue'] in ['6/m','6/mmm','3m1', '31m', '3']:
    3421 #             return [[pfx+'A0',dpdA[0]],[pfx+'A2',dpdA[2]]]
    3422 #         elif SGData['SGLaue'] in ['3R', '3mR']:
    3423 #             return [[pfx+'A0',dpdA[0]+dpdA[1]+dpdA[2]],[pfx+'A3',dpdA[3]+dpdA[4]+dpdA[5]]]                       
    3424 #         elif SGData['SGLaue'] in ['m3m','m3']:
    3425 #             return [[pfx+'A0',dpdA[0]]]
    3426            
    3427 #     # create a list of dependent variables and set up a dictionary to hold their derivatives
    3428 #     depDerivDict = {}
    3429 #     for j in dependentVars:
    3430 #         depDerivDict[j] = np.zeros(shape=(len(x)))
    3431 #     #print 'dependent vars',dependentVars
    3432 #     hId = Histogram['hId']
    3433 #     hfx = ':%d:'%(hId)
    3434 #     bakType = calcControls[hfx+'bakType']
    3435 #     dMdv = np.zeros(shape=(len(varylist),len(x)))
    3436 #     # do not need dMdv to be a masked array at this point. Moved conversion to later in this routine.
    3437 #     #dMdv = ma.array(dMdv,mask=np.outer(np.ones(len(varylist)),ma.getmaskarray(x)))      #x is a MaskedArray!
    3438 #     dMdb,dMddb,dMdpk = G2pwd.getBackgroundDerv(hfx,parmDict,bakType,calcControls[hfx+'histType'],x)
    3439 #     if hfx+'Back;0' in varylist: # for now assume that Back;x vars to not appear in constraints
    3440 #         bBpos = varylist.index(hfx+'Back;0')
    3441 #         dMdv[bBpos:bBpos+len(dMdb)] += dMdb     #TODO crash if bck parms tossed
    3442 #     names = [hfx+'DebyeA',hfx+'DebyeR',hfx+'DebyeU']
    3443 #     for name in varylist:
    3444 #         if 'Debye' in name:
    3445 #             id = int(name.split(';')[-1])
    3446 #             parm = name[:int(name.rindex(';'))]
    3447 #             ip = names.index(parm)
    3448 #             dMdv[varylist.index(name)] += dMddb[3*id+ip]
    3449 #     names = [hfx+'BkPkpos',hfx+'BkPkint',hfx+'BkPksig',hfx+'BkPkgam']
    3450 #     for name in varylist:
    3451 #         if 'BkPk' in name:
    3452 #             parm,id = name.split(';')
    3453 #             id = int(id)
    3454 #             if parm in names:
    3455 #                 ip = names.index(parm)
    3456 #                 dMdv[varylist.index(name)] += dMdpk[4*id+ip]
    3457 #     cw = np.diff(ma.getdata(x))
    3458 #     cw = np.append(cw,cw[-1])
    3459 #     Ka2 = False #also for TOF!
    3460 #     if 'C' in calcControls[hfx+'histType']:   
    3461 #         shl = max(parmDict[hfx+'SH/L'],0.002)
    3462 #         if hfx+'Lam1' in parmDict.keys():
    3463 #             wave = parmDict[hfx+'Lam1']
    3464 #             Ka2 = True
    3465 #             lamRatio = 360*(parmDict[hfx+'Lam2']-parmDict[hfx+'Lam1'])/(np.pi*parmDict[hfx+'Lam1'])
    3466 #             kRatio = parmDict[hfx+'I(L2)/I(L1)']
    3467 #         else:
    3468 #             wave = parmDict[hfx+'Lam']
    3469 #     #print '#1 getPowderProfileDerv t=',time.time()-starttime
    3470 #     for phase in Histogram['Reflection Lists']:
    3471 #         refDict = Histogram['Reflection Lists'][phase]
    3472 #         if phase not in Phases:     #skips deleted or renamed phases silently!
    3473 #             continue
    3474 #         Phase = Phases[phase]
    3475 #         SGData = Phase['General']['SGData']
    3476 #         SGMT = np.array([ops[0].T for ops in SGData['SGOps']])
    3477 #         im = 0
    3478 #         if Phase['General'].get('Modulated',False):
    3479 #             SSGData = Phase['General']['SSGData']
    3480 #             im = 1  #offset in SS reflection list
    3481 #             #??
    3482 #         pId = Phase['pId']
    3483 #         pfx = '%d::'%(pId)
    3484 #         phfx = '%d:%d:'%(pId,hId)
    3485 #         Dij = GetDij(phfx,SGData,parmDict)
    3486 #         A = [parmDict[pfx+'A%d'%(i)]+Dij[i] for i in range(6)]
    3487 #         G,g = G2lat.A2Gmat(A)       #recip & real metric tensors
    3488 #         GA,GB = G2lat.Gmat2AB(G)    #Orthogonalization matricies
    3489 #         if not Phase['General'].get('doPawley') and not parmDict[phfx+'LeBail']:
    3490 #             if im:
    3491 #                 dFdvDict = SStructureFactorDerv(refDict,im,G,hfx,pfx,SGData,SSGData,calcControls,parmDict)
    3492 #             else:
    3493 #                 if Phase['General']['Type'] == 'magnetic':
    3494 #                     dFdvDict = StructureFactorDervMag(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
    3495 #                 else:
    3496 #                     dFdvDict = StructureFactorDerv2(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
    3497 # #            print 'sf-derv time %.3fs'%(time.time()-time0)
    3498 #             ApplyRBModelDervs(dFdvDict,parmDict,rigidbodyDict,Phase)
    3499 #         #print '#2 getPowderProfileDerv t=',time.time()-starttime
    3500 #         # determine the parameters that will have derivatives computed only at end
    3501 #         nonatomvarylist = []
    3502 #         for name in varylist:
    3503 #             if '::RBV;' not in name:
    3504 #                 try:
    3505 #                     aname = name.split(pfx)[1][:2]
    3506 #                     if aname not in ['Af','dA','AU','RB','AM','Xs','Xc','Ys','Yc','Zs','Zc',    \
    3507 #                         'Tm','Xm','Ym','Zm','U1','U2','U3']: continue # skip anything not an atom or rigid body param
    3508 #                 except IndexError:
    3509 #                     continue
    3510 #             nonatomvarylist.append(name)
    3511 #         nonatomdependentVars = []
    3512 #         for name in dependentVars:
    3513 #             if '::RBV;' not in name:
    3514 #                 try:
    3515 #                     aname = name.split(pfx)[1][:2]
    3516 #                     if aname not in ['Af','dA','AU','RB','AM','Xs','Xc','Ys','Yc','Zs','Zc',    \
    3517 #                         'Tm','Xm','Ym','Zm','U1','U2','U3']: continue # skip anything not an atom or rigid body param
    3518 #                 except IndexError:
    3519 #                     continue
    3520 #             nonatomdependentVars.append(name)
    3521 #         #==========================================================================================
    3522 #         #==========================================================================================
    3523 #         for iref,refl in enumerate(refDict['RefList']):
    3524 #             if im:
    3525 #                 h,k,l,m = refl[:4]
    3526 #             else:
    3527 #                 h,k,l = refl[:3]
    3528 #             Uniq = np.inner(refl[:3],SGMT)
    3529 #             if 'T' in calcControls[hfx+'histType']:
    3530 #                 wave = refl[14+im]
    3531 #             dIdsh,dIdsp,dIdpola,dIdPO,dFdODF,dFdSA,dFdAb,dFdEx = GetIntensityDerv(refl,im,wave,Uniq,G,g,pfx,phfx,hfx,SGData,calcControls,parmDict)
    3532 #             if 'C' in calcControls[hfx+'histType']:        #CW powder
    3533 #                 Wd,fmin,fmax = G2pwd.getWidthsCW(refl[5+im],refl[6+im],refl[7+im],shl)
    3534 #             else: #'T'OF
    3535 #                 Wd,fmin,fmax = G2pwd.getWidthsTOF(refl[5+im],refl[12+im],refl[13+im],refl[6+im],refl[7+im])
    3536 #             iBeg = np.searchsorted(x,refl[5+im]-fmin)
    3537 #             iFin = np.searchsorted(x,refl[5+im]+fmax)
    3538 #             if not iBeg+iFin:       #peak below low limit - skip peak
    3539 #                 continue
    3540 #             elif not iBeg-iFin:     #peak above high limit - done
    3541 #                 break
    3542 #             pos = refl[5+im]
    3543 #             #itim=0;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3544 #             if 'C' in calcControls[hfx+'histType']:
    3545 #                 tanth = tand(pos/2.0)
    3546 #                 costh = cosd(pos/2.0)
    3547 #                 lenBF = iFin-iBeg
    3548 #                 dMdpk = np.zeros(shape=(6,lenBF))
    3549 #                 dMdipk = G2pwd.getdFCJVoigt3(refl[5+im],refl[6+im],refl[7+im],shl,ma.getdata(x[iBeg:iFin]))
    3550 #                 for i in range(5):
    3551 #                     dMdpk[i] += 100.*cw[iBeg:iFin]*refl[11+im]*refl[9+im]*dMdipk[i]
    3552 #                 dervDict = {'int':dMdpk[0],'pos':dMdpk[1],'sig':dMdpk[2],'gam':dMdpk[3],'shl':dMdpk[4],'L1/L2':np.zeros_like(dMdpk[0])}
    3553 #                 if Ka2:
    3554 #                     pos2 = refl[5+im]+lamRatio*tanth       # + 360/pi * Dlam/lam * tan(th)
    3555 #                     iBeg2 = np.searchsorted(x,pos2-fmin)
    3556 #                     iFin2 = np.searchsorted(x,pos2+fmax)
    3557 #                     if iBeg2-iFin2:
    3558 #                         lenBF2 = iFin2-iBeg2
    3559 #                         dMdpk2 = np.zeros(shape=(6,lenBF2))
    3560 #                         dMdipk2 = G2pwd.getdFCJVoigt3(pos2,refl[6+im],refl[7+im],shl,ma.getdata(x[iBeg2:iFin2]))
    3561 #                         for i in range(5):
    3562 #                             dMdpk2[i] = 100.*cw[iBeg2:iFin2]*refl[11+im]*refl[9+im]*kRatio*dMdipk2[i]
    3563 #                         dMdpk2[5] = 100.*cw[iBeg2:iFin2]*refl[11+im]*dMdipk2[0]
    3564 #                         dervDict2 = {'int':dMdpk2[0],'pos':dMdpk2[1],'sig':dMdpk2[2],'gam':dMdpk2[3],'shl':dMdpk2[4],'L1/L2':dMdpk2[5]*refl[9]}
    3565 #             else:   #'T'OF
    3566 #                 lenBF = iFin-iBeg
    3567 #                 if lenBF < 0:   #bad peak coeff
    3568 #                     break
    3569 #                 dMdpk = np.zeros(shape=(6,lenBF))
    3570 #                 dMdipk = G2pwd.getdEpsVoigt(refl[5+im],refl[12+im],refl[13+im],refl[6+im],refl[7+im],ma.getdata(x[iBeg:iFin]))
    3571 #                 for i in range(6):
    3572 #                     dMdpk[i] += refl[11+im]*refl[9+im]*dMdipk[i]      #cw[iBeg:iFin]*
    3573 #                 dervDict = {'int':dMdpk[0],'pos':dMdpk[1],'alp':dMdpk[2],'bet':dMdpk[3],'sig':dMdpk[4],'gam':dMdpk[5]}           
    3574 #             #itim=1;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3575 #             if Phase['General'].get('doPawley'):
    3576 #                 dMdpw = np.zeros(len(x))
    3577 #                 try:
    3578 #                     if im:
    3579 #                         pIdx = pfx+'PWLref:'+str(pawleyLookup[pfx+'%d,%d,%d,%d'%(h,k,l,m)])
    3580 #                     else:
    3581 #                         pIdx = pfx+'PWLref:'+str(pawleyLookup[pfx+'%d,%d,%d'%(h,k,l)])
    3582 #                     idx = varylist.index(pIdx)
    3583 #                     dMdpw[iBeg:iFin] = dervDict['int']/refl[9+im]
    3584 #                     if Ka2: #not for TOF either
    3585 #                         dMdpw[iBeg2:iFin2] += dervDict2['int']/refl[9+im]
    3586 #                     dMdv[idx] = dMdpw
    3587 #                 except: # ValueError:
    3588 #                     pass
    3589 #             if 'C' in calcControls[hfx+'histType']:
    3590 #                 dpdA,dpdw,dpdZ,dpdSh,dpdTr,dpdX,dpdY,dpdV = GetReflPosDerv(refl,im,wave,A,pfx,hfx,calcControls,parmDict)
    3591 #                 names = {hfx+'Scale':[dIdsh,'int'],hfx+'Polariz.':[dIdpola,'int'],phfx+'Scale':[dIdsp,'int'],
    3592 #                     hfx+'U':[tanth**2,'sig'],hfx+'V':[tanth,'sig'],hfx+'W':[1.0,'sig'],
    3593 #                     hfx+'X':[1.0/costh,'gam'],hfx+'Y':[tanth,'gam'],hfx+'SH/L':[1.0,'shl'],
    3594 #                     hfx+'I(L2)/I(L1)':[1.0,'L1/L2'],hfx+'Zero':[dpdZ,'pos'],hfx+'Lam':[dpdw,'pos'],
    3595 #                     hfx+'Shift':[dpdSh,'pos'],hfx+'Transparency':[dpdTr,'pos'],hfx+'DisplaceX':[dpdX,'pos'],
    3596 #                     hfx+'DisplaceY':[dpdY,'pos'],}
    3597 #                 if 'Bragg' in calcControls[hfx+'instType']:
    3598 #                     names.update({hfx+'SurfRoughA':[dFdAb[0],'int'],
    3599 #                         hfx+'SurfRoughB':[dFdAb[1],'int'],})
    3600 #                 else:
    3601 #                     names.update({hfx+'Absorption':[dFdAb,'int'],})
    3602 #             else:   #'T'OF
    3603 #                 dpdA,dpdZ,dpdDC,dpdDA,dpdDB,dpdV = GetReflPosDerv(refl,im,0.0,A,pfx,hfx,calcControls,parmDict)
    3604 #                 names = {hfx+'Scale':[dIdsh,'int'],phfx+'Scale':[dIdsp,'int'],
    3605 #                     hfx+'difC':[dpdDC,'pos'],hfx+'difA':[dpdDA,'pos'],hfx+'difB':[dpdDB,'pos'],
    3606 #                     hfx+'Zero':[dpdZ,'pos'],hfx+'X':[refl[4+im],'gam'],hfx+'Y':[refl[4+im]**2,'gam'],
    3607 #                     hfx+'alpha':[1./refl[4+im],'alp'],hfx+'beta-0':[1.0,'bet'],hfx+'beta-1':[1./refl[4+im]**4,'bet'],
    3608 #                     hfx+'beta-q':[1./refl[4+im]**2,'bet'],hfx+'sig-0':[1.0,'sig'],hfx+'sig-1':[refl[4+im]**2,'sig'],
    3609 #                     hfx+'sig-2':[refl[4+im]**4,'sig'],hfx+'sig-q':[1./refl[4+im]**2,'sig'],
    3610 #                     hfx+'Absorption':[dFdAb,'int'],phfx+'Extinction':[dFdEx,'int'],}
    3611 #             #itim=2;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3612 #             for name in names:
    3613 #                 item = names[name]
    3614 #                 if name in varylist:
    3615 #                     dMdv[varylist.index(name)][iBeg:iFin] += item[0]*dervDict[item[1]]
    3616 #                     if Ka2 and iFin2-iBeg2:
    3617 #                         dMdv[varylist.index(name)][iBeg2:iFin2] += item[0]*dervDict2[item[1]]
    3618 #                 elif name in dependentVars:
    3619 #                     depDerivDict[name][iBeg:iFin] += item[0]*dervDict[item[1]]
    3620 #                     if Ka2 and iFin2-iBeg2:
    3621 #                         depDerivDict[name][iBeg2:iFin2] += item[0]*dervDict2[item[1]]
    3622 #             for iPO in dIdPO:
    3623 #                 if iPO in varylist:
    3624 #                     dMdv[varylist.index(iPO)][iBeg:iFin] += dIdPO[iPO]*dervDict['int']
    3625 #                     if Ka2 and iFin2-iBeg2:
    3626 #                         dMdv[varylist.index(iPO)][iBeg2:iFin2] += dIdPO[iPO]*dervDict2['int']
    3627 #                 elif iPO in dependentVars:
    3628 #                     depDerivDict[iPO][iBeg:iFin] += dIdPO[iPO]*dervDict['int']
    3629 #                     if Ka2 and iFin2-iBeg2:
    3630 #                         depDerivDict[iPO][iBeg2:iFin2] += dIdPO[iPO]*dervDict2['int']
    3631 #             #itim=3;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3632 #             for i,name in enumerate(['omega','chi','phi']):
    3633 #                 aname = pfx+'SH '+name
    3634 #                 if aname in varylist:
    3635 #                     dMdv[varylist.index(aname)][iBeg:iFin] += dFdSA[i]*dervDict['int']
    3636 #                     if Ka2 and iFin2-iBeg2:
    3637 #                         dMdv[varylist.index(aname)][iBeg2:iFin2] += dFdSA[i]*dervDict2['int']
    3638 #                 elif aname in dependentVars:
    3639 #                     depDerivDict[aname][iBeg:iFin] += dFdSA[i]*dervDict['int']
    3640 #                     if Ka2 and iFin2-iBeg2:
    3641 #                         depDerivDict[aname][iBeg2:iFin2] += dFdSA[i]*dervDict2['int']
    3642 #             for iSH in dFdODF:
    3643 #                 if iSH in varylist:
    3644 #                     dMdv[varylist.index(iSH)][iBeg:iFin] += dFdODF[iSH]*dervDict['int']
    3645 #                     if Ka2 and iFin2-iBeg2:
    3646 #                         dMdv[varylist.index(iSH)][iBeg2:iFin2] += dFdODF[iSH]*dervDict2['int']
    3647 #                 elif iSH in dependentVars:
    3648 #                     depDerivDict[iSH][iBeg:iFin] += dFdODF[iSH]*dervDict['int']
    3649 #                     if Ka2 and iFin2-iBeg2:
    3650 #                         depDerivDict[iSH][iBeg2:iFin2] += dFdODF[iSH]*dervDict2['int']
    3651 #             cellDervNames = cellVaryDerv(pfx,SGData,dpdA)
    3652 #             for name,dpdA in cellDervNames:
    3653 #                 if name in varylist:
    3654 #                     dMdv[varylist.index(name)][iBeg:iFin] += dpdA*dervDict['pos']
    3655 #                     if Ka2 and iFin2-iBeg2:
    3656 #                         dMdv[varylist.index(name)][iBeg2:iFin2] += dpdA*dervDict2['pos']
    3657 #                 elif name in dependentVars: #need to scale for mixed phase constraints?
    3658 #                     depDerivDict[name][iBeg:iFin] += dpdA*dervDict['pos']
    3659 #                     if Ka2 and iFin2-iBeg2:
    3660 #                         depDerivDict[name][iBeg2:iFin2] += dpdA*dervDict2['pos']
    3661 #             dDijDict = GetHStrainShiftDerv(refl,im,SGData,phfx,hfx,calcControls,parmDict)
    3662 #             for name in dDijDict:
    3663 #                 if name in varylist:
    3664 #                     dMdv[varylist.index(name)][iBeg:iFin] += dDijDict[name]*dervDict['pos']
    3665 #                     if Ka2 and iFin2-iBeg2:
    3666 #                         dMdv[varylist.index(name)][iBeg2:iFin2] += dDijDict[name]*dervDict2['pos']
    3667 #                 elif name in dependentVars:
    3668 #                     depDerivDict[name][iBeg:iFin] += dDijDict[name]*dervDict['pos']
    3669 #                     if Ka2 and iFin2-iBeg2:
    3670 #                         depDerivDict[name][iBeg2:iFin2] += dDijDict[name]*dervDict2['pos']
    3671 #             #itim=4;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3672 #             for i,name in enumerate([pfx+'mV0',pfx+'mV1',pfx+'mV2']):
    3673 #                 if name in varylist:
    3674 #                     dMdv[varylist.index(name)][iBeg:iFin] += dpdV[i]*dervDict['pos']
    3675 #                     if Ka2 and iFin2-iBeg2:
    3676 #                         dMdv[varylist.index(name)][iBeg2:iFin2] += dpdV[i]*dervDict2['pos']
    3677 #                 elif name in dependentVars:
    3678 #                     depDerivDict[name][iBeg:iFin] += dpdV[i]*dervDict['pos']
    3679 #                     if Ka2 and iFin2-iBeg2:
    3680 #                         depDerivDict[name][iBeg2:iFin2] += dpdV[i]*dervDict2['pos']
    3681 #             if 'C' in calcControls[hfx+'histType']:
    3682 #                 sigDict,gamDict = GetSampleSigGamDerv(refl,im,wave,G,GB,SGData,hfx,phfx,calcControls,parmDict)
    3683 #             else:   #'T'OF
    3684 #                 sigDict,gamDict = GetSampleSigGamDerv(refl,im,0.0,G,GB,SGData,hfx,phfx,calcControls,parmDict)
    3685 #             for name in gamDict:
    3686 #                 if name in varylist:
    3687 #                     dMdv[varylist.index(name)][iBeg:iFin] += gamDict[name]*dervDict['gam']
    3688 #                     if Ka2 and iFin2-iBeg2:
    3689 #                         dMdv[varylist.index(name)][iBeg2:iFin2] += gamDict[name]*dervDict2['gam']
    3690 #                 elif name in dependentVars:
    3691 #                     depDerivDict[name][iBeg:iFin] += gamDict[name]*dervDict['gam']
    3692 #                     if Ka2 and iFin2-iBeg2:
    3693 #                         depDerivDict[name][iBeg2:iFin2] += gamDict[name]*dervDict2['gam']
    3694 #             for name in sigDict:
    3695 #                 if name in varylist:
    3696 #                     dMdv[varylist.index(name)][iBeg:iFin] += sigDict[name]*dervDict['sig']
    3697 #                     if Ka2 and iFin2-iBeg2:
    3698 #                         dMdv[varylist.index(name)][iBeg2:iFin2] += sigDict[name]*dervDict2['sig']
    3699 #                 elif name in dependentVars:
    3700 #                     depDerivDict[name][iBeg:iFin] += sigDict[name]*dervDict['sig']
    3701 #                     if Ka2 and iFin2-iBeg2:
    3702 #                         depDerivDict[name][iBeg2:iFin2] += sigDict[name]*dervDict2['sig']
    3703 #             for name in ['BabA','BabU']:
    3704 #                 if refl[9+im]:
    3705 #                     if phfx+name in varylist:
    3706 #                         dMdv[varylist.index(phfx+name)][iBeg:iFin] += parmDict[phfx+'Scale']*dFdvDict[phfx+name][iref]*dervDict['int']/refl[9+im]
    3707 #                         if Ka2 and iFin2-iBeg2:
    3708 #                             dMdv[varylist.index(phfx+name)][iBeg2:iFin2] += parmDict[phfx+'Scale']*dFdvDict[phfx+name][iref]*dervDict2['int']/refl[9+im]
    3709 #                     elif phfx+name in dependentVars:                   
    3710 #                         depDerivDict[phfx+name][iBeg:iFin] += parmDict[phfx+'Scale']*dFdvDict[phfx+name][iref]*dervDict['int']/refl[9+im]
    3711 #                         if Ka2 and iFin2-iBeg2:
    3712 #                             depDerivDict[phfx+name][iBeg2:iFin2] += parmDict[phfx+'Scale']*dFdvDict[phfx+name][iref]*dervDict2['int']/refl[9+im]                 
    3713 #             #itim=5;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3714 #             if not Phase['General'].get('doPawley') and not parmDict[phfx+'LeBail']:
    3715 #                 #do atom derivatives -  for RB,F,X & U so far - how do I scale mixed phase constraints?
    3716 #                 corr = 0.
    3717 #                 corr2 = 0.
    3718 #                 if refl[9+im]:             
    3719 #                     corr = dervDict['int']/refl[9+im]
    3720 #                     #if Ka2 and iFin2-iBeg2:
    3721 #                     #    corr2 = dervDict2['int']/refl[9+im]
    3722 #                 #itim=6;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3723 #                 for name in nonatomvarylist:
    3724 #                     dMdv[varylist.index(name)][iBeg:iFin] += dFdvDict[name][iref]*corr
    3725 #                     if Ka2 and iFin2-iBeg2:
    3726 #                        dMdv[varylist.index(name)][iBeg2:iFin2] += dFdvDict[name][iref]*corr2
    3727 #                 #itim=7;timelist[itim] += time.time()-timestart[itim]; timestart[itim+1] = time.time()
    3728 #                 for name in nonatomdependentVars:
    3729 #                    depDerivDict[name][iBeg:iFin] += dFdvDict[name][iref]*corr
    3730 #                    if Ka2 and iFin2-iBeg2:
    3731 #                        depDerivDict[name][iBeg2:iFin2] += dFdvDict[name][iref]*corr2
    3732 #                 #itim=8;timelist[itim] += time.time()-timestart[itim]   
    3733 #     #        print 'profile derv time: %.3fs'%(time.time()-time0)
    3734 #     # now process derivatives in constraints
    3735 #     #print '#3 getPowderProfileDerv t=',time.time()-starttime
    3736 #     #print timelist,sum(timelist)
    3737 #     dMdv[:,ma.getmaskarray(x)] = 0.  # instead of masking, zero out masked values
    3738 #     dMdv = ma.array(dMdv,mask=np.outer(np.ones(len(varylist)),ma.getmaskarray(x)))      #x is a MaskedArray!
    3739 #     G2mv.Dict2Deriv(varylist,depDerivDict,dMdv)
    3740 #     #if GSASIIpath.GetConfigValue('debug'):
    3741 #     #    print 'end getPowderProfileDerv t=',time.time()-starttime
    3742 #     return dMdv
    3743 
    37443393def getPowderProfileDervMP(args):
    37453394    '''Computes the derivatives of the computed powder pattern with respect to all
     
    41183767        else:   #correct!!
    41193768            if Phase['General']['Type'] == 'magnetic':  #is this going to work for single crystal mag data?
    4120                 dFdvDict = MagStructureFactorDerv(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
     3769                dFdvDict = MagStructureFactorDerv2(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
    41213770            else:
    41223771                dFdvDict = StructureFactorDerv2(refDict,G,hfx,pfx,SGData,calcControls,parmDict)
Note: See TracChangeset for help on using the changeset viewer.