diffpy.mpdf 1.0.3__tar.gz → 1.0.4__tar.gz

{diffpy_mpdf-1.0.3/diffpy.mpdf.egg-info → diffpy_mpdf-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diffpy.mpdf
-Version: 1.0.3
+Version: 1.0.4
 Summary: Tools for magnetic PDF analysis.
 Author-email: Benjamin Frandsen <benfrandsen@byu.edu>
 License: Copyright 2022 BENJAMIN ALLEN FRANDSEN
@@ -31,6 +31,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
+Dynamic: license-file
 
 ## diffpy.mpdf
 

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4}/diffpy/mpdf/magstructure.py

@@ -24,6 +24,12 @@ from diffpy.mpdf.magutils import generateAtomsXYZ, generateFromUnitCell, \
     generateSpinsXYZ, getFFparams, jCalc, spinsFromAtoms, atomsFromSpins, \
     findAtomIndices, visualizeSpins
 
+# neutron magnetic moment in nuclear magnetons
+GAMMA = 1.913
+
+# classical electron radius in units of 10^-14 m so square is in barns
+r_0 = 0.281794
+
 class MagSpecies:
     """Store information for a single species of magnetic atom.
 
@@ -478,7 +484,7 @@ class MagStructure:
         else:
             self.ff = ff
         if K1 is None:
-            self.K1 = 0.66667*(1.913*2.81794/2.0)**2*2.0**2*0.5*(0.5+1)
+            self.K1 = 0.66667*(GAMMA * r_0/2.0)**2*2.0**2*0.5*(0.5+1)
         else:
             self.K1 = K1
         if K2 is None:
@@ -726,8 +732,8 @@ class MagStructure:
             K1 += self.fractions[key]*ga*np.sqrt(Ja*(Ja+1))
             K2 += self.fractions[key]*ga**2*Ja*(Ja+1)
         K1 = K1**2
-        K1 *= (1.913*2.81794/2.0)**2*2.0/3.0
-        K2 *= (1.913*2.81794/2.0)**2*2.0/3.0
+        K1 *= (GAMMA * r_0/2.0)**2*2.0/3.0
+        K2 *= (GAMMA * r_0/2.0)**2*2.0/3.0
         self.K1 = K1
         self.K2 = K2
 

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4}/diffpy/mpdf/magutils.py

@@ -27,6 +27,12 @@ from scipy.signal import convolve, fftconvolve, correlate
 from scipy.optimize import least_squares
 import periodictable as pt
 
+# neutron magnetic moment in nuclear magnetons
+GAMMA = 1.913
+
+# classical electron radius in units of 10^-14 m so square is in barns
+r_0 = 0.281794
+
 def generateAtomsXYZ(struc, rmax=30.0, strucIdxs=[0], square=False):
     """Generate array of atomic Cartesian coordinates from a given structure.
 
@@ -869,7 +875,7 @@ def getStdUnc(fitResult, data, dataErr=None, numConstraints=0):
     return pUnc, chisq
 
 
-def optimizedSubtraction(rhigh, dhigh, rlow, dlow):
+def optimizedSubtraction(rhigh, dhigh, rlow, dlow, p0=[0.999, 0.1], print_output=False):
     '''
     This routine stretches and broadens a low-temperature atomic PDF fit residual
     to match a high-temperature fit residual as closely as possible. The idea is
@@ -880,6 +886,10 @@ def optimizedSubtraction(rhigh, dhigh, rlow, dlow):
     dhigh = high-temperature atomic PDF fit residual
     rlow = r array for low-temperature atomic PDF fit residual
     dlow = low-temperature atomic PDF fit residual
+    p0 = initial guesses for stretching and broadening factors; [0.999, 0.1]
+        by default.
+    print_output (bool): True if the optimized stretching and broadening factors
+        should be printed. False by default.
     Note: the high- and low-temperature fits should be over the same r range
     '''
 
@@ -900,9 +910,9 @@ def optimizedSubtraction(rhigh, dhigh, rlow, dlow):
         msk = (x <= x.max() / stretch)
         return ycomp[msk] - newy[msk]
 
-    p0 = [0.999, 0.1]  # typical starting guesses
     opt = least_squares(residual, p0, args=(rlow, dlow, dhigh))
-    print(opt.x)
+    if print_output:
+        print(opt.x)
     stretch = opt.x[0]
     msk = (rlow <= rlow.max() / stretch)
     newdllow = dhigh[msk] - residual(opt.x, rlow, dlow, dhigh)
@@ -1083,7 +1093,7 @@ def calculatemPDF(xyz, sxyz, gfactors=np.array([2.0]), calcIdxs=np.array([0]),
                   rstep=0.01, rmin=0.0, rmax=20.0, psigma=0.1, qmin=0,
                   qmax=-1, qdamp=0.0, extendedrmin=4.0, extendedrmax=4.0,
                   orderedScale=1.0,
-                  K1=0.66667 * (1.913 * 2.81794 / 2.0) ** 2 * 2.0 ** 2 * 0.5 * (0.5 + 1),
+                  K1=0.66667 * (GAMMA * r_0 / 2.0) ** 2 * 2.0 ** 2 * 0.5 * (0.5 + 1),
                   rho0=0, netMag=0, corrLength=0, linearTermMethod='exact',
                   applyEnvelope=False, qwindow=np.array([0]),
                   qgrid=np.array([0])):
@@ -1229,7 +1239,7 @@ def calculatemPDF(xyz, sxyz, gfactors=np.array([2.0]), calcIdxs=np.array([0]),
         fr = s1 / r + r * (ss2[-1] - ss2)
 
     ### prefactor
-    fr /= len(calcIdxs) * K1 / (1.913 * 2.81794 / 2.0) ** 2
+    fr /= len(calcIdxs) * K1 / (GAMMA * r_0 / 2.0) ** 2
     if applyEnvelope and (corrLength != 0):
         fr *= np.exp(-r/corrLength)
 
@@ -1253,10 +1263,10 @@ def calculatemPDF(xyz, sxyz, gfactors=np.array([2.0]), calcIdxs=np.array([0]),
     else:
         if corrLength == 0:
             linearTerm = 4 * np.pi * r * rho0 * (2.0/3.0) * netMag**2  \
-                         / ( K1 / (1.913 * 2.81794 / 2.0) ** 2)
+                         / ( K1 / (GAMMA * r_0 / 2.0) ** 2)
         else:
             linearTerm = 4 * np.pi * r * rho0 * (2.0 / 3.0) * netMag ** 2 * np.exp(-r/corrLength) \
-                          / ( K1 / (1.913 * 2.81794 / 2.0) ** 2)
+                          / ( K1 / (GAMMA * r_0 / 2.0) ** 2)
     fr -= linearTerm
 
 
@@ -1313,7 +1323,7 @@ def calculateDr(r, fr, q, ff, paraScale=1.0, rmintr=-5.0, rmaxtr=5.0,
     Returns: numpy array for the unnormalized mPDF Dr.
     """
     if K1 is None:
-        K1 = 0.66667 * (1.913 * 2.81794 / 2.0) ** 2 * 2.0 ** 2 * 0.5 * (0.5 + 1)
+        K1 = 0.66667 * (GAMMA * r_0 / 2.0) ** 2 * 2.0 ** 2 * 0.5 * (0.5 + 1)
     if K2 is None:
         K2 = K1
     rsr, sr = cosTransform(q, ff, rmintr, rmaxtr, drtr)
@@ -1402,7 +1412,8 @@ def calculate_ordered_moment(mc,nucScale,returnUncertainty=False,inputUnc=[]):
     struc = mstr.struc
     mstr.calcMagneticAtomRatio()
     ns = mstr.magneticAtomRatio # fraction of total atoms that are magnetic
-    bAvg = calculateAvgB(struc) # average nuclear scattering length
+    bAvg = calculateAvgB(struc) # average nuclear scattering length in fm
+    bAvg /= 10.0 # convert to units of 10^-14 m
     g = mstr.gfactors[0] # g factor for the magnetic structrue
     vectorMag = np.linalg.norm(mstr.spins[0]) # magnitude of spin vectors used in calculation
     m = g * np.sqrt(mc.ordScale * bAvg**2 / (nucScale * ns)) * vectorMag
@@ -1445,6 +1456,7 @@ def calculate_ordered_scale(magstruc,orderedMoment,nucScale=1.0):
     magstruc.calcMagneticAtomRatio()
     ns = magstruc.magneticAtomRatio # fraction of total atoms that are magnetic
     bAvg = calculateAvgB(struc) # average nuclear scattering length
+    bAvg /= 10.0 # convert to units of 10^-14 m
     g = np.mean(magstruc.gfactors) # g factor for the magnetic structrue
     vectorMag = calculate_avg_spin_magnitude(magstruc) # magnitude of spin vectors used in calculation
     oscl = (orderedMoment / g / vectorMag)**2 * nucScale * ns / bAvg**2 # ordered scale factor

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4}/diffpy/mpdf/mciftools.py

@@ -39,7 +39,7 @@ def create_from_mcif(mcif, ffparamkey=None, rmaxAtoms=20, S=0.5, L=0.0,
     Creates a MagStructure object from an MCIF file.
     
     Note: The only acceptable incommensurate structures at the moment are 1-k
-    structures with no     Fourier harmonics (i.e. only coefficients for
+    structures with no Fourier harmonics (i.e. only coefficients for
     n = 1) and no atoms with nonzero average magnetic moment.
 
     Args:
@@ -259,7 +259,17 @@ def create_from_mcif(mcif, ffparamkey=None, rmaxAtoms=20, S=0.5, L=0.0,
         atom.element = newname
 
 
-    #Creates a separate MagSpecies object for each magnetic atom in the unit cell
+    # Determine Lande g factor to convert the moment size (stored in mcif) to momentum size
+    if J is None:
+        J = S + L
+    if gS is None:
+        gS = 1.0 + 1.0*(S*(S+1)-L*(L+1))/(J*(J+1))
+    if gL is None:
+        gL = 0.5 + 1.0*(L*(L+1)-S*(S+1))/(2*J*(J+1))
+    if g is None:
+        g = gS + gL
+    
+    # Creates a separate MagSpecies object for each magnetic atom in the unit cell
     for idx in mag_idx:
         new_mspec = MagSpecies(ffparamkey=ffparamkey, rmaxAtoms=rmaxAtoms,
                                S=S, L=L, J=J, gS=gS, gL=gL, g=g,
@@ -277,7 +287,9 @@ def create_from_mcif(mcif, ffparamkey=None, rmaxAtoms=20, S=0.5, L=0.0,
         if incomm:
             new_mspec.kvecs = np.append(new_mspec.kvecs,[-k],axis=0)
             new_mspec.basisvecs = np.append(new_mspec.basisvecs,[np.conjugate(basis_vecs[idx])],axis=0)
-        new_mspec.avgmom = all_mom[idx] if incomm else np.array([0, 0, 0])
+        new_mspec.basisvecs /= g # convert to angular momentum rather than magnetic moment
+        new_mspec.avgmom = np.array(all_mom[idx]) if incomm else np.array([0, 0, 0])
+        new_mspec.avgmom = np.array(new_mspec.avgmom) / g
 
         mstruc.loadSpecies(new_mspec)
 

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4}/diffpy/mpdf/mpdftransformer.py

@@ -26,7 +26,7 @@ from diffpy.mpdf.magutils import sinTransformDirectIntegration
 
 def resid1(p, ff, iq, diq):
     """Scale the magnetic form factor to the data."""
-    return (iq - (p[0] * ff)**2)/diq
+    return (iq - p[0] * ff**2)/diq
 
 def bkgfunc(p, q):
     """Generate polynomial to fit to F(Q)."""
@@ -84,11 +84,14 @@ def getmPDF_unnormalized(q, iq, qmin, qmax, rmin=0.05, rmax=100, rstep=0.01):
     iq = iq[mask]
     r, dmag = sinTransformDirectIntegration(q, q*iq, rmin=rmin, rmax=rmax,
                                             rstep=rstep)
+    dmag *= np.sqrt(2.0/np.pi) # sinTransformDirectIntegration carries factor of sqrt(2/pi), but need 2/pi for mPDF
+
     return r, dmag
 
 def getmPDF_normalized(q, iq, ff, qmin, qmax, qmaxinst, rpoly,
                   diq=None, qstart=3.0, rmin=0.05, rmax=100, rstep=0.01,
-                  window='None', qmaxwindow=0, windowedgewidth=0.1):
+                  window='None', qmaxwindow=0, windowedgewidth=0.1,
+                  ff2scale=0.0):
     """PDFgetX3-style processing to produce the normalized mPDF.
     
     This function is called by an instance of MPDFtransformer to generate
@@ -122,6 +125,12 @@ def getmPDF_normalized(q, iq, ff, qmin, qmax, qmaxinst, rpoly,
         qmaxwindow (float): Sets the q value where the window goes to 0.
         windowedgewidth (float): approximate width of Fermi-Dirac window.
             Not applicable to 'Lorch' or 'None' window options.
+        ff2scale (float): scale factor applied to the squared form factor
+            before normalizing. If left as 0.0 by default, the scale factor
+            is determined via least-squares fit to data over the interval
+            from qstart to qmaxinst. Ideally, this scale factor should be
+            equal to (2/3)(gamma_n r_0 / 2)^2 g^2 J(J+1),
+            where (gamma_n r_0 / 2)^2 = 0.07265 in units of barns.
 
     Returns:
         Dictionary with the following keys and values:
@@ -136,6 +145,7 @@ def getmPDF_normalized(q, iq, ff, qmin, qmax, qmaxinst, rpoly,
         'fqm': measured (i.e. uncorrected) reduced magnetic structure function.
         'dfqm': estimated uncertainties for fqm.
         'windowFunc': the window function used.
+        'ffscale': the scale factor applied to the form factor.
         'ff2': the scaled, squared magnetic form factor.
         'bkg': the final polynomial background used.
         'bkga': the lower-degree polynomial background.
@@ -159,15 +169,18 @@ def getmPDF_normalized(q, iq, ff, qmin, qmax, qmaxinst, rpoly,
     diq = np.nan_to_num(diq, nan=1000*np.nanmax(diq))
 
     mask1 = np.logical_and(q>=qstart, q<=qmaxinst)
-    opt1 = least_squares(resid1, [1], args=(ff[mask1], iq[mask1], diq[mask1]))
+    
+    if ff2scale == 0.0:
+        opt1 = least_squares(resid1, [1], args=(ff[mask1], iq[mask1], diq[mask1]))
 
-    scl = opt1.x[0]
+        ff2scale = opt1.x[0]
 
-    ff = scl * ff
+    ff = np.sqrt(ff2scale) * ff
 
     # create a dictionary containing the items to be returned and add the
     # scaled squared form factor and initial mask to it.
     rv = {}
+    rv['ff2scale'] = ff2scale
     rv['ff2'] = ff**2
     rv['mask1'] = mask1
 
@@ -236,6 +249,7 @@ def getmPDF_normalized(q, iq, ff, qmin, qmax, qmaxinst, rpoly,
 
     # normalized mPDF
     r, gmag = sinTransformDirectIntegration(q[mask3], fqc[mask3], rmin=rmin, rmax=rmax, rstep=rstep)
+    gmag *= np.sqrt(2.0/np.pi) # sinTransformDirectIntegration carries factor of sqrt(2/pi), but need 2/pi for mPDF
 
     rv['r'] = r
     rv['gmag'] = gmag
@@ -311,7 +325,7 @@ class MPDFtransformer:
     def __init__(self, q=None, iq=None, ff=None, qmin=0.0, qmax=10.0,
                  qmaxinst=None, rpoly=1.8, diq=None, qstart=3.0, rmin=0.05,
                  rmax=100.0, rstep=0.01, window=None, qmaxwindow=None,
-                 windowedgewidth=0.1):
+                 windowedgewidth=0.1, ff2scale=0.0):
         if q is None:
             self.q = np.array([0])
         else:
@@ -348,6 +362,7 @@ class MPDFtransformer:
         else:
             self.qmaxwindow = qmaxwindow
         self.windowedgewidth = windowedgewidth
+        self.ff2scale = ff2scale
         self._r = np.array([])
         self._dmag = np.array([])
         self._gmag = np.array([])
@@ -499,7 +514,8 @@ class MPDFtransformer:
                                         self.qmax, self.qmaxinst, self.rpoly,
                                         1.0*self.diq, self.qstart, self.rmin,
                                         self.rmax, self.rstep, self.window,
-                                        self.qmaxwindow, self.windowedgewidth)
+                                        self.qmaxwindow, self.windowedgewidth,
+                                        1.0*self.ff2scale)
             self._r = output['r']
             self._gmag = output['gmag']
             self._sqm = output['sqm']
@@ -516,6 +532,7 @@ class MPDFtransformer:
             self._mask1 = output['mask1']
             self._mask2 = output['mask2']
             self._mask3 = output['mask3']
+            self.ff2scale = output['ff2scale']
             self._normalized_done = True
 
     def makePlots(self, showuncertainty=True):

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4/diffpy.mpdf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diffpy.mpdf
-Version: 1.0.3
+Version: 1.0.4
 Summary: Tools for magnetic PDF analysis.
 Author-email: Benjamin Frandsen <benfrandsen@byu.edu>
 License: Copyright 2022 BENJAMIN ALLEN FRANDSEN
@@ -31,6 +31,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: AUTHORS.txt
+Dynamic: license-file
 
 ## diffpy.mpdf
 

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4}/diffpy.mpdf.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ LICENSE.txt
 MANIFEST.in
 README.md
 pyproject.toml
-setup.py
 diffpy/__init__.py
 diffpy.mpdf.egg-info/PKG-INFO
 diffpy.mpdf.egg-info/SOURCES.txt

{diffpy_mpdf-1.0.3 → diffpy_mpdf-1.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "diffpy.mpdf"
-version = "1.0.3"
+version = "1.0.4"
 authors = [
   { name="Benjamin Frandsen", email="benfrandsen@byu.edu" },
 ]

diffpy_mpdf-1.0.3/setup.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python
-##############################################################################
-#
-# diffpy.mpdf         by Frandsen Group
-#                     Benjamin A. Frandsen benfrandsen@byu.edu
-#                     (c) 2022 Benjamin Allen Frandsen
-#                      All rights reserved
-#
-# File coded by:    Benjamin Frandsen
-#
-# See AUTHORS.txt for a list of people who contributed.
-# See LICENSE.txt for license information.
-#
-##############################################################################
-
-# Installation script for diffpy.mpdf
-
-"""mpdf - Tools for magnetic pair distribution function analysis.
-Packages:   diffpy.mpdf
-"""
-
-import os
-from setuptools import setup, find_packages
-
-# Use this version when git data are not available, like in git zip archive.
-# Update when tagging a new release.
-FALLBACK_VERSION = '1.0.1.post0'
-
-# versioncfgfile holds version data for git commit hash and date.
-# It must reside in the same directory as version.py.
-MYDIR = os.path.dirname(os.path.abspath(__file__))
-versioncfgfile = os.path.join(MYDIR, 'diffpy/mpdf/version.cfg')
-gitarchivecfgfile = versioncfgfile.replace('version.cfg', 'gitarchive.cfg')
-
-def gitinfo():
-    from subprocess import Popen, PIPE
-    kw = dict(stdout=PIPE, cwd=MYDIR)
-    proc = Popen(['git', 'describe', '--match=v[[:digit:]]*'], **kw)
-    desc = proc.stdout.read()
-    proc = Popen(['git', 'log', '-1', '--format=%H %at %ai'], **kw)
-    glog = proc.stdout.read()
-    rv = {}
-    rv['version'] = '.post'.join(desc.strip().split('-')[:2]).lstrip('v')
-    rv['commit'], rv['timestamp'], rv['date'] = glog.strip().split(None, 2)
-    return rv
-
-
-def getversioncfg():
-    import re
-    try:
-        from configparser import RawConfigParser
-    except:
-        from ConfigParser import RawConfigParser
-    vd0 = dict(version=FALLBACK_VERSION, commit='', date='', timestamp=0)
-    # first fetch data from gitarchivecfgfile, ignore if it is unexpanded
-    g = vd0.copy()
-    cp0 = RawConfigParser(vd0)
-    cp0.read(gitarchivecfgfile)
-    if '$Format:' not in cp0.get('DEFAULT', 'commit'):
-        g = cp0.defaults()
-        mx = re.search(r'\btag: v(\d[^,]*)', g.pop('refnames'))
-        if mx:
-            g['version'] = mx.group(1)
-    # then try to obtain version data from git.
-    gitdir = os.path.join(MYDIR, '.git')
-    if os.path.exists(gitdir) or 'GIT_DIR' in os.environ:
-        try:
-            g = gitinfo()
-        except OSError:
-            pass
-    # finally, check and update the active version file
-    cp = RawConfigParser()
-    cp.read(versioncfgfile)
-    d = cp.defaults()
-    rewrite = not d or (g['commit'] and (
-        g['version'] != d.get('version') or g['commit'] != d.get('commit')))
-    if rewrite:
-        cp.set('DEFAULT', 'version', g['version'])
-        cp.set('DEFAULT', 'commit', g['commit'])
-        cp.set('DEFAULT', 'date', g['date'])
-        cp.set('DEFAULT', 'timestamp', g['timestamp'])
-        cp.write(open(versioncfgfile, 'w'))
-    return cp
-
-#versiondata = getversioncfg()  ### python3 incompatible
-
-# define distribution
-setup_args = dict(
-        name = "diffpy.mpdf",
-        #version = versiondata.get('DEFAULT', 'version'),
-        version = '1.0.3',
-        #namespace_packages = ['diffpy'],
-        packages = find_packages(),
-        #test_suite = 'diffpy.mpdf.tests',
-        #include_package_data = True,
-        #zip_safe = False,
-        #author = 'Benjamin A. Frandsen group',
-        #author_email = 'benfrandsen@byu.edu',
-        #maintainer = 'Benjamin Frandsen',
-        #maintainer_email = 'benfrandsen@byu.edu',
-        description = "Tools for magnetic PDF analysis.",
-        license = 'BSD-3-clause',
-        #url = "https://github.com/FrandsenGroup/diffpy.mpdf",
-        #keywords = "mPDF magnetic PDF",
-        classifiers = [
-            # List of possible values at
-            # http://pypi.python.org/pypi?:action=list_classifiers
-            'Development Status :: 5 - Production/Stable',
-            'Environment :: Console',
-            'Intended Audience :: Developers',
-            'Intended Audience :: Science/Research',
-            'License :: OSI Approved :: BSD License',
-            'Operating System :: MacOS :: MacOS X',
-            'Operating System :: Microsoft :: Windows',
-            'Operating System :: POSIX',
-            'Operating System :: Unix',
-            'Programming Language :: Python :: 3.7',
-            'Topic :: Scientific/Engineering :: Physics',
-        ],
-)
-
-if __name__ == '__main__':
-    setup(**setup_args)
-
-# End of file