pmagpy 4.3.7__py3-none-any.whl → 4.3.9__py3-none-any.whl

pmagpy/pmag.py

@@ -13,7 +13,6 @@ from .mapping import map_magic
 from pmagpy import contribution_builder as cb
 from . import find_pmag_dir
 from pmag_env import set_env
-import pandas as pd
 import SPD.lib.leastsq_jacobian as lib_k
 
 WARNINGS = {'cartopy': False}
@@ -179,14 +178,14 @@ def get_dictkey(In, k, dtype):
         if dtype == 'f':
             if d[k] == "":
                 Out.append(0)
-            elif d[k] == None:
+            elif d[k] is None:
                 Out.append(0)
             else:
                 Out.append(float(d[k]))
         if dtype == 'int':
             if d[k] == "":
                 Out.append(0)
-            elif d[k] == None:
+            elif d[k] is None:
                 Out.append(0)
             else:
                 Out.append(int(d[k]))
@@ -740,10 +739,10 @@ def getsampVGP(SampRec, SiteNFO, data_model=2.5):
         site = get_dictitem(SiteNFO, 'site', SampRec['site'], 'T')
         if len(site) > 1:
             lat, lon, i = None, None, 0
-            while lat == None or lon == None or i >= len(site):
-                if site[i]['lat'] != None:
+            while lat is None or lon is None or i >= len(site):
+                if site[i]['lat'] is not None:
                     lat = float(site[i]['lat'])
-                if site[i]['lon'] != None:
+                if site[i]['lon'] is not None:
                     lon = float(site[i]['lon'])
                 i += 1
         else:
@@ -777,10 +776,10 @@ def getsampVGP(SampRec, SiteNFO, data_model=2.5):
                             SampRec['er_site_name'], 'T')
         if len(site) > 1:
             lat, lon, i = None, None, 0
-            while lat == None or lon == None or i >= len(site):
-                if site[i]['site_lat'] != None:
+            while lat is None or lon is None or i >= len(site):
+                if site[i]['site_lat'] is not None:
                     lat = float(site[i]['site_lat'])
-                if site[i]['site_lon'] != None:
+                if site[i]['site_lon'] is not None:
                     lon = float(site[i]['site_lon'])
                 i += 1
         else:
@@ -1140,8 +1139,8 @@ def get_sb_df(df, mm97=False):
         Ns = df.dir_n
         Ls = np.radians(df.lat)
         A95s = 140./np.sqrt(ks*Ns)
-        Sw2_n = 0.335*(A95s**2)*(2.*(1.+3.*np.sin(Ls)**2) /
-                                 (5.-3.*np.sin(Ls)**2))
+        Sw2_n = 0.335*(A95s**2)*(2.*(1.+3.*np.sin(Ls)**2)**2 /
+                                 (5.+3.*np.sin(Ls)**2))
         return np.sqrt(Sp2-Sw2_n.mean())
     else:
         return np.sqrt(Sp2)
@@ -1403,86 +1402,6 @@ def dia_vgp(*args):  # new function interface by J.Holmes, SIO, 6/1/2011
     return plong.tolist(), plat.tolist(), dp.tolist(), dm.tolist()
 
 
-def int_pars(x, y, vds, **kwargs):
-    """
-    Depreciated 9/7/2022 
-    
-    Calculates York regression and paleointensity parameters (with Tauxe Fvds).
-    """
-    # first do linear regression a la York
-    # do Data Model 3 way:
-    if 'version' in list(kwargs.keys()) and kwargs['version'] == 3:
-        n_key = 'int_n_measurements'
-        b_key = 'int_b'
-        sigma_key = 'int_b_sigma'
-        f_key = 'int_f'
-        fvds_key = 'int_fvds'
-        g_key = 'int_g'
-        q_key = 'int_q'
-        b_beta_key = 'int_b_beta'
-
-    else:  # version 2
-        n_key = 'specimen_int_n'
-        b_key = 'specimen_b'
-        sigma_key = 'specimen_b_sigma'
-        f_key = 'specimen_f'
-        fvds_key = 'specimen_fvds'
-        g_key = 'specimen_g'
-        q_key = 'specimen_q'
-        b_beta_key = 'specimen_b_beta'
-
-    xx, yer, xer, xyer, yy, xsum, ysum, xy = 0., 0., 0., 0., 0., 0., 0., 0.
-    xprime, yprime = [], []
-    pars = {}
-    pars[n_key] = len(x)
-    n = float(len(x))
-    if n <= 2:
-        print("shouldn't be here at all!")
-        return pars, 1
-    for i in range(len(x)):
-        xx += x[i]**2.
-        yy += y[i]**2.
-        xy += x[i] * y[i]
-        xsum += x[i]
-        ysum += y[i]
-    xsig = np.sqrt((xx - (xsum**2 / n)) / (n - 1.))
-    ysig = np.sqrt((yy - (ysum**2 / n)) / (n - 1.))
-    sum = 0
-    for i in range(int(n)):
-        yer += (y[i] - (ysum / n))**2.
-        xer += (x[i] - (xsum / n))**2.
-        xyer += (y[i] - (ysum / n)) * (x[i] - (xsum / n))
-    slop = -np.sqrt(yer / xer)
-    pars[b_key] = slop
-    s1 = 2. * yer - 2. * slop * xyer
-    s2 = (n - 2.) * xer
-    sigma = np.sqrt(s1 / s2)
-    pars[sigma_key] = sigma
-    s = (xy - (xsum * ysum / n)) / (xx - (xsum**2 / n))
-    r = (s * xsig) / ysig
-    pars["specimen_rsc"] = r**2.
-    ytot = abs(ysum / n - slop * xsum / n)
-    for i in range(int(n)):
-        xprime.append(((slop * x[i] + y[i] - ytot) / (2. * slop)))
-        yprime.append(((slop * x[i] + y[i] - ytot) / 2.) + ytot)
-    sumdy, dy = 0, []
-    dyt = abs(yprime[0] - yprime[int(n) - 1])
-    for i in range((int(n) - 1)):
-        dy.append(abs(yprime[i + 1] - yprime[i]))
-        sumdy += dy[i]**2.
-    f = dyt / ytot
-    pars[f_key] = f
-    pars["specimen_ytot"] = ytot
-    ff = dyt / vds
-    pars[fvds_key] = ff
-    ddy = (1. / dyt) * sumdy
-    g = 1. - ddy / dyt
-    pars[g_key] = g
-    q = abs(slop) * f * g / sigma
-    pars[q_key] = q
-    pars[b_beta_key] = -sigma / slop
-    return pars, 0
-
 def get_curve(araiblock,**kwargs):
 #   curvature stuff
     pars={}
@@ -1750,34 +1669,6 @@ def vector_mean(data):
     return dir, R
 
 
-def mark_dmag_rec(s, ind, data):
-    """
-    Depreciated 9/14/2022
-    
-    Edits demagnetization data to mark "bad" points with measurement_flag.
-    """
-    datablock = []
-    for rec in data:
-        if rec['er_specimen_name'] == s:
-            meths = rec['magic_method_codes'].split(':')
-            if 'LT-NO' in meths or 'LT-AF-Z' in meths or 'LT-T-Z' in meths:
-                datablock.append(rec)
-    dmagrec = datablock[ind]
-    for k in range(len(data)):
-        meths = data[k]['magic_method_codes'].split(':')
-        if 'LT-NO' in meths or 'LT-AF-Z' in meths or 'LT-T-Z' in meths:
-            if data[k]['er_specimen_name'] == s:
-                if data[k]['treatment_temp'] == dmagrec['treatment_temp'] and data[k]['treatment_ac_field'] == dmagrec['treatment_ac_field']:
-                    if data[k]['measurement_dec'] == dmagrec['measurement_dec'] and data[k]['measurement_inc'] == dmagrec['measurement_inc'] and data[k]['measurement_magn_moment'] == dmagrec['measurement_magn_moment']:
-                        if data[k]['measurement_flag'] == 'g':
-                            flag = 'b'
-                        else:
-                            flag = 'g'
-                        data[k]['measurement_flag'] = flag
-                        break
-    return data
-
-
 def mark_samp(Samps, data, crd):
 
     return Samps
@@ -2157,55 +2048,6 @@ def sort_magic_data(magic_data, sort_name):
     return magic_data_sorted
 
 
-def upload_read(infile, table):
-    """
-    Depreciated 9/14/2022
-    
-    Reads a table from a MagIC upload (or downloaded) txt file and puts data in a
-    list of dictionaries.
-    """
-    delim = 'tab'
-    hold, magic_data, magic_record, magic_keys = [], [], {}, []
-    f = open(infile, "r")
-#
-# look for right table
-#
-    line = f.readline()[:-1]
-    file_type = line.split('\t')[1]
-    if file_type == 'delimited':
-        file_type = line.split('\t')[2]
-    if delim == 'tab':
-        line = f.readline()[:-1].split('\t')
-    else:
-        f.close()
-        print("only tab delimitted files are supported now")
-        return
-    while file_type != table:
-        while line[0][0:5] in f.readlines() != ">>>>>":
-            pass
-        line = f.readline()[:-1]
-        file_type = line.split('\t')[1]
-        if file_type == 'delimited':
-            file_type = line.split('\t')[2]
-        ine = f.readline()[:-1].split('\t')
-    while line[0][0:5] in f.readlines() != ">>>>>":
-        for key in line:
-            magic_keys.append(key)
-        for line in f.readlines():
-            rec = line[:-1].split('\t')
-            hold.append(rec)
-        for rec in hold:
-            magic_record = {}
-            if len(magic_keys) != len(rec):
-                print("Uneven record lengths detected: ", rec)
-                input("Return to continue.... ")
-            for k in range(len(magic_keys)):
-                magic_record[magic_keys[k]] = rec[k]
-            magic_data.append(magic_record)
-    f.close()
-    return magic_data
-
-
 def putout(ofile, keylist, Rec):
     """
     Writes out a magic format record to ofile.
@@ -2643,36 +2485,6 @@ def find_samp_rec(s, data, az_type):
     return orient
 
 
-def vspec(data):
-    """
-    Depreciated 9/14/2022
-    
-    Takes the vector mean of replicate measurements at a given step.
-    """
-    vdata, Dirdata, step_meth = [], [], []
-    tr0 = data[0][0]  # set beginning treatment
-    data.append("Stop")
-    k, R = 1, 0
-    for i in range(k, len(data)):
-        Dirdata = []
-        if data[i][0] != tr0:
-            if i == k:  # sample is unique
-                vdata.append(data[i - 1])
-                step_meth.append(" ")
-            else:  # sample is not unique
-                for l in range(k - 1, i):
-                    Dirdata.append([data[l][1], data[l][2], data[l][3]])
-                dir, R = vector_mean(Dirdata)
-                vdata.append([data[i - 1][0], dir[0], dir[1], R / (i - k + 1), '1', 'g'])
-                step_meth.append("DE-VM")
-            tr0 = data[i][0]
-            k = i + 1
-            if tr0 == "stop":
-                break
-    del data[-1]
-    return step_meth, vdata
-
-
 def Vdiff(D1, D2):
     """
     Calculates the vector difference between two directions D1, D2.
@@ -2876,6 +2688,34 @@ def Tmatrix(X):
     return T
 
 
+def vspec(data):
+    """
+    Takes the vector mean of replicate measurements at a given step. Used in zeq_magic2.py.
+    """
+    vdata, Dirdata, step_meth = [], [], []
+    tr0 = data[0][0]  # set beginning treatment
+    data.append("Stop")
+    k, R = 1, 0
+    for i in range(k, len(data)):
+        Dirdata = []
+        if data[i][0] != tr0:
+            if i == k:  # sample is unique
+                vdata.append(data[i - 1])
+                step_meth.append(" ")
+            else:  # sample is not unique
+                for l in range(k - 1, i):
+                    Dirdata.append([data[l][1], data[l][2], data[l][3]])
+                dir, R = vector_mean(Dirdata)
+                vdata.append([data[i - 1][0], dir[0], dir[1], R / (i - k + 1), '1', 'g'])
+                step_meth.append("DE-VM")
+            tr0 = data[i][0]
+            k = i + 1
+            if tr0 == "stop":
+                break
+    del data[-1]
+    return step_meth, vdata
+
+
 def dir2cart(d):
     """
     Converts a list or array of vector directions in degrees (declination,
@@ -3247,9 +3087,105 @@ def circ(dec, dip, alpha,npts=201):
     return D_out, I_out
 
 
+def int_pars(x, y, vds, **kwargs):
+    """
+    This function calculates York regression and paleointensity parameters
+    (with Tauxe Fvds), building a dictionary which is used in PintPars.
+
+    Parameters
+    ----------
+    x : x values of TRM and NRM points on the Arai plot
+    y : y values of TRM and NRM points on the Arai plot
+    vds : vector difference sum (from pmag.dovds)
+    **kwargs
+
+    Returns
+    -------
+    pars : dctionary of regression and paleointensity parameters
+    errcode : bool
+        0 if no errors, 1 if too few points 
+
+    """
+    # first do linear regression a la York
+    # do Data Model 3 way:
+    if 'version' in list(kwargs.keys()) and kwargs['version'] == 3:
+        n_key = 'int_n_measurements'
+        b_key = 'int_b'
+        sigma_key = 'int_b_sigma'
+        f_key = 'int_f'
+        fvds_key = 'int_fvds'
+        g_key = 'int_g'
+        q_key = 'int_q'
+        b_beta_key = 'int_b_beta'
+
+    else:  # version 2
+        n_key = 'specimen_int_n'
+        b_key = 'specimen_b'
+        sigma_key = 'specimen_b_sigma'
+        f_key = 'specimen_f'
+        fvds_key = 'specimen_fvds'
+        g_key = 'specimen_g'
+        q_key = 'specimen_q'
+        b_beta_key = 'specimen_b_beta'
+
+    xx, yer, xer, xyer, yy, xsum, ysum, xy = 0., 0., 0., 0., 0., 0., 0., 0.
+    xprime, yprime = [], []
+    pars = {}
+    pars[n_key] = len(x)
+    n = float(len(x))
+    if n <= 2:
+        print("shouldn't be here at all!")
+        return pars, 1
+    for i in range(len(x)):
+        xx += x[i]**2.
+        yy += y[i]**2.
+        xy += x[i] * y[i]
+        xsum += x[i]
+        ysum += y[i]
+    xsig = np.sqrt((xx - (xsum**2 / n)) / (n - 1.))
+    ysig = np.sqrt((yy - (ysum**2 / n)) / (n - 1.))
+    sum = 0
+    for i in range(int(n)):
+        yer += (y[i] - (ysum / n))**2.
+        xer += (x[i] - (xsum / n))**2.
+        xyer += (y[i] - (ysum / n)) * (x[i] - (xsum / n))
+    slop = -np.sqrt(yer / xer)
+    pars[b_key] = slop
+    s1 = 2. * yer - 2. * slop * xyer
+    s2 = (n - 2.) * xer
+    sigma = np.sqrt(s1 / s2)
+    pars[sigma_key] = sigma
+    s = (xy - (xsum * ysum / n)) / (xx - (xsum**2 / n))
+    r = (s * xsig) / ysig
+    pars["specimen_rsc"] = r**2.
+    ytot = abs(ysum / n - slop * xsum / n)
+    for i in range(int(n)):
+        xprime.append(((slop * x[i] + y[i] - ytot) / (2. * slop)))
+        yprime.append(((slop * x[i] + y[i] - ytot) / 2.) + ytot)
+    sumdy, dy = 0, []
+    dyt = abs(yprime[0] - yprime[int(n) - 1])
+    for i in range((int(n) - 1)):
+        dy.append(abs(yprime[i + 1] - yprime[i]))
+        sumdy += dy[i]**2.
+    f = dyt / ytot
+    pars[f_key] = f
+    pars["specimen_ytot"] = ytot
+    ff = dyt / vds
+    pars[fvds_key] = ff
+    ddy = (1. / dyt) * sumdy
+    g = 1. - ddy / dyt
+    pars[g_key] = g
+    q = abs(slop) * f * g / sigma
+    pars[q_key] = q
+    pars[b_beta_key] = -sigma / slop
+    return pars, 0
+
+
 def PintPars(datablock, araiblock, zijdblock, start, end, accept, **kwargs):
     """
     Calculate the paleointensity with magic parameters and make some definitions.
+    
+    Uses functions int_pars and dovds
     """
     if 'version' in list(kwargs.keys()) and kwargs['version'] == 3:
         meth_key = 'method_codes'
@@ -3956,22 +3892,6 @@ def getkeys(table):
         keys.append("measurement_csd")
     return keys
 
-# commented out as of 8/18/22
-#def getnames():
-#    """
-#    get mail names
-#    """
-#    namestring = ""
-#    addmore = 1
-#    while addmore:
-#        scientist = input("Enter  name  - <Return> when done ")
-#        if scientist != "":
-#            namestring = namestring + ":" + scientist
-#        else:
-#            namestring = namestring[1:]
-#            addmore = 0
-#    return namestring
-
 
 def magic_help(keyhelp):
     """
@@ -4556,44 +4476,52 @@ def fisher_mean(data):
 
 def gausspars(data):
     """
-    Calculates gaussian statistics for data. 
-    
-    Parmeters
-    ---------
-    data : array of data 
-    
-    Returns 
+    Compute the mean and standard deviation of a one-dimensional array of numerical data.
+
+    This function calculates the arithmetic mean and the standard deviation
+    (using N - 1 in the denominator) for a single series of observations.
+
+    Parameters
+    ----------
+    data : array_like
+        One-dimensional list or array of numerical data.
+
+    Returns
     -------
-    mean : array the length of the data array  
-    stdev : second array the length of the data array
-    
+    tuple of (float, float)
+        Mean and standard deviation of the input data. The standard deviation is
+        calculated with N - 1 degrees of freedom.
+
+    Notes
+    -----
+    - If the input array is empty, returns a tuple of two empty strings.
+    - If the array contains a single observation, returns the observation as the mean
+      and 0 as the standard deviation.
+    - The standard deviation is computed using the `ddof` parameter in NumPy, which
+      stands for *delta degrees of freedom*. The divisor in the calculation is
+      ``N - ddof``, where ``N`` is the number of observations. Here, ``ddof=1`` is
+      used so that the result is the **sample standard deviation**, the conventional
+      choice when the data represent a sample from a larger population.
+
     Examples
     --------
-    >>> data=np.loadtxt('data_files/vector_mean/vector_mean_example.dat')
-    >>> pmag.gausspars(data)
-    (array([  154.72699999999995,    44.43599999999999, 23709.242399999992  ]),
-     array([  166.93766686153165 ,    19.578257988354988,
-        11563.604723319804   ]))
-          
-    >>> data = np.array([  [16.0,    43.0, 21620.33],
-           [30.5,    53.6, 12922.58],
-            [6.9,    33.2, 15780.08],
-          [352.5,    40.2, 33947.52], 
-          [354.2,    45.1, 19725.45]])
-    >>> pmag.gausspars(data)
-    (array([  152.02, 43.019999999999996, 20799.192]),
-     array([1.839818931308187e+02, 7.427112494098901e+00, 8.092252785230450e+03]))
+    >>> data = np.array([54.15, 49.08, 50.62, 49.44, 49.64])
+    >>> mean, stdev = pmag.gausspars(data)
+    >>> print("Mean:", mean)
+    >>> print("Standard deviation:", stdev)
+    Mean: 50.586
+    Standard deviation: 2.072409225997607
     """
-    N, mean, d = len(data), 0., 0.
+    data = np.asarray(data)
+    N = len(data)
+
     if N < 1:
         return "", ""
     if N == 1:
-        return data[0], 0
-    for j in range(N):
-        mean += data[j] / float(N)
-    for j in range(N):
-        d += (data[j] - mean)**2
-    stdev = np.sqrt(d * (1./(float(N - 1))))
+        return float(data[0]), 0.0
+
+    mean = np.mean(data)
+    stdev = np.std(data, ddof=1)
     return mean, stdev
 
 
@@ -4831,66 +4759,6 @@ def fisher_by_pol(data):
     return FisherByPoles
 
 
-def dolnp3_0(Data):
-    """
-    DEPRECATED!!  USE dolnp()
-    Description: takes a list of dicts with the controlled vocabulary of 3_0 and calls dolnp on them after reformating for compatibility.
-    Parameters
-    ---------------_
-    Data : nested list of dictionaries with keys
-        dir_dec
-        dir_inc
-        dir_tilt_correction
-        method_codes
-
-    Returns
-    -------
-        ReturnData : dictionary with keys
-            dec : fisher mean dec of data in Data
-            inc : fisher mean inc of data in Data
-            n_lines : number of directed lines [method_code = DE-BFL or DE-FM]
-            n_planes : number of best fit planes [method_code = DE-BFP]
-            alpha95  : fisher confidence circle from Data
-            R : fisher R value of Data
-            K : fisher k value of Data
-    Effects
-        prints to screen in case of no data
-    """
-    if len(Data) == 0:
-        print("This function requires input Data have at least 1 entry")
-        return {}
-    if len(Data) == 1:
-        ReturnData = {}
-        ReturnData["dec"] = Data[0]['dir_dec']
-        ReturnData["inc"] = Data[0]['dir_inc']
-        ReturnData["n_total"] = '1'
-        if "DE-BFP" in Data[0]['method_codes']:
-            ReturnData["n_lines"] = '0'
-            ReturnData["n_planes"] = '1'
-        else:
-            ReturnData["n_planes"] = '0'
-            ReturnData["n_lines"] = '1'
-        ReturnData["alpha95"] = ""
-        ReturnData["R"] = ""
-        ReturnData["K"] = ""
-        return ReturnData
-    else:
-        LnpData = []
-        for n, d in enumerate(Data):
-            LnpData.append({})
-            LnpData[n]['dec'] = d['dir_dec']
-            LnpData[n]['inc'] = d['dir_inc']
-            LnpData[n]['tilt_correction'] = d['dir_tilt_correction']
-            if 'method_codes' in list(d.keys()):
-                if "DE-BFP" in d['method_codes']:
-                    LnpData[n]['dir_type'] = 'p'
-                else:
-                    LnpData[n]['dir_type'] = 'l'
-        # get a sample average from all specimens
-        ReturnData = dolnp(LnpData, 'dir_type')
-        return ReturnData
-
-
 def dolnp(data, direction_type_key):
     """
     Returns fisher mean, a95 for data using the method of McFadden and McElhinny 1988 for lines and planes.
@@ -5130,76 +4998,6 @@ def process_data_for_mean(data, direction_type_key):
     return fdata, n_lines, L, n_planes, E
 
 
-def scoreit(pars, PmagSpecRec, accept, text, verbose):
-    """
-    Depreciated 9/14/2022
-    
-    Gets a grade for a given set of data, spits out stuff.
-    """
-    s = PmagSpecRec["er_specimen_name"]
-    PmagSpecRec["measurement_step_min"] = '%8.3e' % (
-        pars["measurement_step_min"])
-    PmagSpecRec["measurement_step_max"] = '%8.3e' % (
-        pars["measurement_step_max"])
-    PmagSpecRec["measurement_step_unit"] = pars["measurement_step_unit"]
-    PmagSpecRec["specimen_int_n"] = '%i' % (pars["specimen_int_n"])
-    PmagSpecRec["specimen_lab_field_dc"] = '%8.3e' % (
-        pars["specimen_lab_field_dc"])
-    PmagSpecRec["specimen_int"] = '%8.3e ' % (pars["specimen_int"])
-    PmagSpecRec["specimen_b"] = '%5.3f ' % (pars["specimen_b"])
-    PmagSpecRec["specimen_q"] = '%5.1f ' % (pars["specimen_q"])
-    PmagSpecRec["specimen_f"] = '%5.3f ' % (pars["specimen_f"])
-    PmagSpecRec["specimen_fvds"] = '%5.3f' % (pars["specimen_fvds"])
-    PmagSpecRec["specimen_b_beta"] = '%5.3f' % (pars["specimen_b_beta"])
-    PmagSpecRec["specimen_int_mad"] = '%7.1f' % (pars["specimen_int_mad"])
-    PmagSpecRec["specimen_dec"] = '%7.1f' % (pars["specimen_dec"])
-    PmagSpecRec["specimen_inc"] = '%7.1f' % (pars["specimen_inc"])
-    PmagSpecRec["specimen_int_dang"] = '%7.1f ' % (pars["specimen_int_dang"])
-    PmagSpecRec["specimen_drats"] = '%7.1f ' % (pars["specimen_drats"])
-    PmagSpecRec["specimen_int_ptrm_n"] = '%i ' % (pars["specimen_int_ptrm_n"])
-    PmagSpecRec["specimen_rsc"] = '%6.4f ' % (pars["specimen_rsc"])
-    PmagSpecRec["specimen_md"] = '%i ' % (int(pars["specimen_md"]))
-    PmagSpecRec["specimen_b_sigma"] = '%5.3f ' % (pars["specimen_b_sigma"])
-    if 'specimen_scat' in list(pars.keys()):
-        PmagSpecRec['specimen_scat'] = pars['specimen_scat']
-    if 'specimen_gmax' in list(pars.keys()):
-        PmagSpecRec['specimen_gmax'] = '%5.3f' % (pars['specimen_gmax'])
-    if 'specimen_frac' in list(pars.keys()):
-        PmagSpecRec['specimen_frac'] = '%5.3f' % (pars['specimen_frac'])
-    # PmagSpecRec["specimen_Z"]='%7.1f'%(pars["specimen_Z"])
-  # check score
-    #
-    kill = grade(PmagSpecRec, accept, 'specimen_int')
-    Grade = ""
-    if len(kill) == 0:
-        Grade = 'A'
-    else:
-        Grade = 'F'
-    pars["specimen_grade"] = Grade
-    if verbose == 0:
-        return pars, kill
-    diffcum = 0
-    if pars['measurement_step_unit'] == 'K':
-        outstr = "specimen     Tmin  Tmax  N  lab_field  B_anc  b  q  f(coe)  Fvds  beta  MAD  Dang  Drats  Nptrm  Grade  R  MD%  sigma  Gamma_max \n"
-        pars_out = (s, (pars["measurement_step_min"] - 273), (pars["measurement_step_max"] - 273), (pars["specimen_int_n"]), 1e6 * (pars["specimen_lab_field_dc"]), 1e6 * (pars["specimen_int"]), pars["specimen_b"], pars["specimen_q"], pars["specimen_f"], pars["specimen_fvds"],
-                    pars["specimen_b_beta"], pars["specimen_int_mad"], pars["specimen_int_dang"], pars["specimen_drats"], pars["specimen_int_ptrm_n"], pars["specimen_grade"], np.sqrt(pars["specimen_rsc"]), int(pars["specimen_md"]), pars["specimen_b_sigma"], pars['specimen_gamma'])
-        outstring = '%s %4.0f %4.0f %i %4.1f %4.1f %5.3f %5.1f %5.3f %5.3f %5.3f  %7.1f %7.1f %7.1f %s %s %6.3f %i %5.3f %7.1f' % pars_out + '\n'
-    elif pars['measurement_step_unit'] == 'J':
-        outstr = "specimen     Wmin  Wmax  N  lab_field  B_anc  b  q  f(coe)  Fvds  beta  MAD  Dang  Drats  Nptrm  Grade  R  MD%  sigma  ThetaMax DeltaMax GammaMax\n"
-        pars_out = (s, (pars["measurement_step_min"]), (pars["measurement_step_max"]), (pars["specimen_int_n"]), 1e6 * (pars["specimen_lab_field_dc"]), 1e6 * (pars["specimen_int"]), pars["specimen_b"], pars["specimen_q"], pars["specimen_f"], pars["specimen_fvds"], pars["specimen_b_beta"],
-                    pars["specimen_int_mad"], pars["specimen_int_dang"], pars["specimen_drats"], pars["specimen_int_ptrm_n"], pars["specimen_grade"], np.sqrt(pars["specimen_rsc"]), int(pars["specimen_md"]), pars["specimen_b_sigma"], pars["specimen_theta"], pars["specimen_delta"], pars["specimen_gamma"])
-        outstring = '%s %4.0f %4.0f %i %4.1f %4.1f %5.3f %5.1f %5.3f %5.3f %5.3f  %7.1f %7.1f %7.1f %s %s %6.3f %i %5.3f %7.1f %7.1f %7.1f' % pars_out + '\n'
-    if pars["specimen_grade"] != "A":
-        print('\n killed by:')
-        for k in kill:
-            print(k, ':, criterion set to: ',
-                  accept[k], ', specimen value: ', pars[k])
-        print('\n')
-    print(outstr)
-    print(outstring)
-    return pars, kill
-
-
 def b_vdm(B, lat):
     """
     Converts a magnetic field value of list of values to  virtual dipole moment (VDM)
@@ -6183,6 +5981,75 @@ def dobingham(di_block):
     return bpars
 
 
+def scoreit(pars, PmagSpecRec, accept, text, verbose):
+    """
+    This function produces a grade for a given set of data. Used in thellier_magic2.py and
+    microwave_magic.py.
+    """
+    s = PmagSpecRec["er_specimen_name"]
+    PmagSpecRec["measurement_step_min"] = '%8.3e' % (
+        pars["measurement_step_min"])
+    PmagSpecRec["measurement_step_max"] = '%8.3e' % (
+        pars["measurement_step_max"])
+    PmagSpecRec["measurement_step_unit"] = pars["measurement_step_unit"]
+    PmagSpecRec["specimen_int_n"] = '%i' % (pars["specimen_int_n"])
+    PmagSpecRec["specimen_lab_field_dc"] = '%8.3e' % (
+        pars["specimen_lab_field_dc"])
+    PmagSpecRec["specimen_int"] = '%8.3e ' % (pars["specimen_int"])
+    PmagSpecRec["specimen_b"] = '%5.3f ' % (pars["specimen_b"])
+    PmagSpecRec["specimen_q"] = '%5.1f ' % (pars["specimen_q"])
+    PmagSpecRec["specimen_f"] = '%5.3f ' % (pars["specimen_f"])
+    PmagSpecRec["specimen_fvds"] = '%5.3f' % (pars["specimen_fvds"])
+    PmagSpecRec["specimen_b_beta"] = '%5.3f' % (pars["specimen_b_beta"])
+    PmagSpecRec["specimen_int_mad"] = '%7.1f' % (pars["specimen_int_mad"])
+    PmagSpecRec["specimen_dec"] = '%7.1f' % (pars["specimen_dec"])
+    PmagSpecRec["specimen_inc"] = '%7.1f' % (pars["specimen_inc"])
+    PmagSpecRec["specimen_int_dang"] = '%7.1f ' % (pars["specimen_int_dang"])
+    PmagSpecRec["specimen_drats"] = '%7.1f ' % (pars["specimen_drats"])
+    PmagSpecRec["specimen_int_ptrm_n"] = '%i ' % (pars["specimen_int_ptrm_n"])
+    PmagSpecRec["specimen_rsc"] = '%6.4f ' % (pars["specimen_rsc"])
+    PmagSpecRec["specimen_md"] = '%i ' % (int(pars["specimen_md"]))
+    PmagSpecRec["specimen_b_sigma"] = '%5.3f ' % (pars["specimen_b_sigma"])
+    if 'specimen_scat' in list(pars.keys()):
+        PmagSpecRec['specimen_scat'] = pars['specimen_scat']
+    if 'specimen_gmax' in list(pars.keys()):
+        PmagSpecRec['specimen_gmax'] = '%5.3f' % (pars['specimen_gmax'])
+    if 'specimen_frac' in list(pars.keys()):
+        PmagSpecRec['specimen_frac'] = '%5.3f' % (pars['specimen_frac'])
+    # PmagSpecRec["specimen_Z"]='%7.1f'%(pars["specimen_Z"])
+  # check score
+    #
+    kill = grade(PmagSpecRec, accept, 'specimen_int')
+    Grade = ""
+    if len(kill) == 0:
+        Grade = 'A'
+    else:
+        Grade = 'F'
+    pars["specimen_grade"] = Grade
+    if verbose == 0:
+        return pars, kill
+    diffcum = 0
+    if pars['measurement_step_unit'] == 'K':
+        outstr = "specimen     Tmin  Tmax  N  lab_field  B_anc  b  q  f(coe)  Fvds  beta  MAD  Dang  Drats  Nptrm  Grade  R  MD%  sigma  Gamma_max \n"
+        pars_out = (s, (pars["measurement_step_min"] - 273), (pars["measurement_step_max"] - 273), (pars["specimen_int_n"]), 1e6 * (pars["specimen_lab_field_dc"]), 1e6 * (pars["specimen_int"]), pars["specimen_b"], pars["specimen_q"], pars["specimen_f"], pars["specimen_fvds"],
+                    pars["specimen_b_beta"], pars["specimen_int_mad"], pars["specimen_int_dang"], pars["specimen_drats"], pars["specimen_int_ptrm_n"], pars["specimen_grade"], np.sqrt(pars["specimen_rsc"]), int(pars["specimen_md"]), pars["specimen_b_sigma"], pars['specimen_gamma'])
+        outstring = '%s %4.0f %4.0f %i %4.1f %4.1f %5.3f %5.1f %5.3f %5.3f %5.3f  %7.1f %7.1f %7.1f %s %s %6.3f %i %5.3f %7.1f' % pars_out + '\n'
+    elif pars['measurement_step_unit'] == 'J':
+        outstr = "specimen     Wmin  Wmax  N  lab_field  B_anc  b  q  f(coe)  Fvds  beta  MAD  Dang  Drats  Nptrm  Grade  R  MD%  sigma  ThetaMax DeltaMax GammaMax\n"
+        pars_out = (s, (pars["measurement_step_min"]), (pars["measurement_step_max"]), (pars["specimen_int_n"]), 1e6 * (pars["specimen_lab_field_dc"]), 1e6 * (pars["specimen_int"]), pars["specimen_b"], pars["specimen_q"], pars["specimen_f"], pars["specimen_fvds"], pars["specimen_b_beta"],
+                    pars["specimen_int_mad"], pars["specimen_int_dang"], pars["specimen_drats"], pars["specimen_int_ptrm_n"], pars["specimen_grade"], np.sqrt(pars["specimen_rsc"]), int(pars["specimen_md"]), pars["specimen_b_sigma"], pars["specimen_theta"], pars["specimen_delta"], pars["specimen_gamma"])
+        outstring = '%s %4.0f %4.0f %i %4.1f %4.1f %5.3f %5.1f %5.3f %5.3f %5.3f  %7.1f %7.1f %7.1f %s %s %6.3f %i %5.3f %7.1f %7.1f %7.1f' % pars_out + '\n'
+    if pars["specimen_grade"] != "A":
+        print('\n killed by:')
+        for k in kill:
+            print(k, ':, criterion set to: ',
+                  accept[k], ', specimen value: ', pars[k])
+        print('\n')
+    print(outstr)
+    print(outstring)
+    return pars, kill
+
+
 def doflip(dec, inc):
     """
     Flips upper hemisphere data to lower hemisphere.
@@ -6468,9 +6335,9 @@ def dokent(data, NN, distribution_95=False):
     sigma1 = sigma1/float(N)
     sigma2 = sigma2/float(N)
     
-    if distribution_95==False:
+    if not distribution_95:
         g = -2.0 * np.log(0.05) / (float(NN) * xmu**2)
-    if distribution_95==True:
+    if distribution_95:
         g = -2.0 * np.log(0.05) / (xmu**2)
     
     if np.sqrt(sigma1 * g) < 1:
@@ -6620,24 +6487,6 @@ def pt_rot(EP, Lats, Lons):
     return RLats, RLons
 
 
-def dread(infile, cols):
-    """
-    Depreciated 9/14/2022 
-    
-    Reads in specimen, tr, dec, inc int into data[].  position of
-    tr, dec, inc, int determined by cols[]
-    """
-    data = []
-    f = open(infile, "r")
-    for line in f.readlines():
-        tmp = line.split()
-        rec = (tmp[0], float(tmp[cols[0]]), float(tmp[cols[1]]), float(tmp[cols[2]]),
-               float(tmp[cols[3]]))
-        data.append(rec)
-    f.close()
-    return data
-
-
 def fshdev(k):
     """
     Generate a random draw from a Fisher distribution with mean declination
@@ -6740,12 +6589,12 @@ def kentdev(kappa, beta, n=1000):
         if (x1*x1+x2*x2)>1:
             continue
 
-        ratio1 = np.exp(-0.5*(a*x1*x1+gamma*x1*x1*x1*x1)-1+lam1*x1);
+        ratio1 = np.exp(-0.5*(a*x1*x1+gamma*x1*x1*x1*x1)-1+lam1*x1)
 
         if u1 > ratio1:
             continue
 
-        ratio2 = np.exp(-0.5*(b*x2*x2-gamma*x2*x2*x2*x2)-c2+lam2*x2);
+        ratio2 = np.exp(-0.5*(b*x2*x2-gamma*x2*x2*x2*x2)-c2+lam2*x2)
 
         if u2 > ratio2:
             continue
@@ -6866,81 +6715,6 @@ def check_F(AniSpec):
     return chi, chi_inv
 
 
-def Dir_anis_corr(InDir, AniSpec):
-    """
-    Depreciated 9/14/2022
-    
-    Takes the 6 element 's' vector and the Dec,Inc 'InDir' data,
-    performs simple anisotropy correction. returns corrected Dec, Inc
-    """
-    Dir = np.zeros((3), 'f')
-    Dir[0] = InDir[0]
-    Dir[1] = InDir[1]
-    Dir[2] = 1.
-    chi, chi_inv = check_F(AniSpec)
-    if chi[0][0] == 1.:
-        return Dir  # isotropic
-    X = dir2cart(Dir)
-    M = np.array(X)
-    H = np.dot(M, chi_inv)
-    return cart2dir(H)
-
-
-def doaniscorr(PmagSpecRec, AniSpec):
-    """
-    Depreciated 9/14/2022
-    
-    Takes the 6 element 's' vector and the Dec,Inc, Int 'Dir' data,
-    performs simple anisotropy correction. returns corrected Dec, Inc, Int
-    """
-    AniSpecRec = {}
-    for key in list(PmagSpecRec.keys()):
-        AniSpecRec[key] = PmagSpecRec[key]
-    Dir = np.zeros((3), 'f')
-    Dir[0] = float(PmagSpecRec["specimen_dec"])
-    Dir[1] = float(PmagSpecRec["specimen_inc"])
-    Dir[2] = float(PmagSpecRec["specimen_int"])
-# check if F test passes!  if anisotropy_sigma available
-    chi, chi_inv = check_F(AniSpec)
-    if chi[0][0] == 1.:  # isotropic
-        cDir = [Dir[0], Dir[1]]  # no change
-        newint = Dir[2]
-    else:
-        X = dir2cart(Dir)
-        M = np.array(X)
-        H = np.dot(M, chi_inv)
-        cDir = cart2dir(H)
-        Hunit = [(H[0] / cDir[2]), (H[1] / cDir[2]), (H[2] / cDir[2])]  # unit vector parallel to Banc
-        Zunit = [0, 0, -1.]  # unit vector parallel to lab field
-        Hpar = np.dot(chi, Hunit)  # unit vector applied along ancient field
-        Zpar = np.dot(chi, Zunit)  # unit vector applied along lab field
-        # intensity of resultant vector from ancient field
-        HparInt = cart2dir(Hpar)[2]
-        # intensity of resultant vector from lab field
-        ZparInt = cart2dir(Zpar)[2]
-        newint = Dir[2] * ZparInt / HparInt
-        if cDir[0] - Dir[0] > 90:
-            cDir[1] = -cDir[1]
-            cDir[0] = (cDir[0] - 180.) % 360.
-    AniSpecRec["specimen_dec"] = '%7.1f' % (cDir[0])
-    AniSpecRec["specimen_inc"] = '%7.1f' % (cDir[1])
-    AniSpecRec["specimen_int"] = '%9.4e' % (newint)
-    AniSpecRec["specimen_correction"] = 'c'
-    if 'magic_method_codes' in list(AniSpecRec.keys()):
-        methcodes = AniSpecRec["magic_method_codes"]
-    else:
-        methcodes = ""
-    if methcodes == "":
-        methcodes = "DA-AC-" + AniSpec['anisotropy_type']
-    if methcodes != "":
-        methcodes = methcodes + ":DA-AC-" + AniSpec['anisotropy_type']
-    if chi[0][0] == 1.:  # isotropic
-        # indicates anisotropy was checked and no change necessary
-        methcodes = methcodes + ':DA-AC-ISO'
-    AniSpecRec["magic_method_codes"] = methcodes.strip(":")
-    return AniSpecRec
-
-
 def vfunc(pars_1, pars_2):
     """
     Calculate the Watson Vw test statistic. Calculated as 2*(Sw-Rw)
@@ -7288,31 +7062,128 @@ def adjust_ages(AgesIn):
                 if agerec[1] == "Years Cal AD (+/-)":
                     AgesOut.append((1950 - agerec[0]) / factor)
     return AgesOut, age_unit
-#
+
+
+def Dir_anis_corr(InDir, AniSpec):
+    """
+    This function takes the 6 element 's' vector and the Dec,Inc 'InDir' data and performs a
+    simple anisotropy correction, returning corrected Dec, Inc. Used in thellier_magic2.py. 
+    """
+    Dir = np.zeros((3), 'f')
+    Dir[0] = InDir[0]
+    Dir[1] = InDir[1]
+    Dir[2] = 1.
+    chi, chi_inv = check_F(AniSpec)
+    if chi[0][0] == 1.:
+        return Dir  # isotropic
+    X = dir2cart(Dir)
+    M = np.array(X)
+    H = np.dot(M, chi_inv)
+    return cart2dir(H)
+
+
+def doaniscorr(PmagSpecRec, AniSpec):
+    """
+    This function takes the 6 element 's' vector and the Dec,Inc, Int 'Dir' data,
+    performs simple anisotropy correction, and returns corrected Dec, Inc, Int. This
+    is used in thellier_magic2.py. 
+    """
+    AniSpecRec = {}
+    for key in list(PmagSpecRec.keys()):
+        AniSpecRec[key] = PmagSpecRec[key]
+    Dir = np.zeros((3), 'f')
+    Dir[0] = float(PmagSpecRec["specimen_dec"])
+    Dir[1] = float(PmagSpecRec["specimen_inc"])
+    Dir[2] = float(PmagSpecRec["specimen_int"])
+# check if F test passes!  if anisotropy_sigma available
+    chi, chi_inv = check_F(AniSpec)
+    if chi[0][0] == 1.:  # isotropic
+        cDir = [Dir[0], Dir[1]]  # no change
+        newint = Dir[2]
+    else:
+        X = dir2cart(Dir)
+        M = np.array(X)
+        H = np.dot(M, chi_inv)
+        cDir = cart2dir(H)
+        Hunit = [(H[0] / cDir[2]), (H[1] / cDir[2]), (H[2] / cDir[2])]  # unit vector parallel to Banc
+        Zunit = [0, 0, -1.]  # unit vector parallel to lab field
+        Hpar = np.dot(chi, Hunit)  # unit vector applied along ancient field
+        Zpar = np.dot(chi, Zunit)  # unit vector applied along lab field
+        # intensity of resultant vector from ancient field
+        HparInt = cart2dir(Hpar)[2]
+        # intensity of resultant vector from lab field
+        ZparInt = cart2dir(Zpar)[2]
+        newint = Dir[2] * ZparInt / HparInt
+        if cDir[0] - Dir[0] > 90:
+            cDir[1] = -cDir[1]
+            cDir[0] = (cDir[0] - 180.) % 360.
+    AniSpecRec["specimen_dec"] = '%7.1f' % (cDir[0])
+    AniSpecRec["specimen_inc"] = '%7.1f' % (cDir[1])
+    AniSpecRec["specimen_int"] = '%9.4e' % (newint)
+    AniSpecRec["specimen_correction"] = 'c'
+    if 'magic_method_codes' in list(AniSpecRec.keys()):
+        methcodes = AniSpecRec["magic_method_codes"]
+    else:
+        methcodes = ""
+    if methcodes == "":
+        methcodes = "DA-AC-" + AniSpec['anisotropy_type']
+    if methcodes != "":
+        methcodes = methcodes + ":DA-AC-" + AniSpec['anisotropy_type']
+    if chi[0][0] == 1.:  # isotropic
+        # indicates anisotropy was checked and no change necessary
+        methcodes = methcodes + ':DA-AC-ISO'
+    AniSpecRec["magic_method_codes"] = methcodes.strip(":")
+    return AniSpecRec
 
 
 def gaussdev(mean, sigma, N=1):
     """
-    Returns a number randomly drawn from a gaussian distribution with the given mean, sigma
-    
-    Parmeters
-    ---------
-    mean : mean of the gaussian distribution from which to draw deviates
-    sigma : standard deviation of same
-    N : number of deviates desired
+    Generate random samples drawn from a Gaussian (normal) distribution.
+
+    This function samples from a normal distribution with a specified mean and
+    standard deviation, returning a NumPy array of length ``N``.
+
+    Parameters
+    ----------
+    mean : float
+        Mean (center) of the normal distribution.
+    sigma : float
+        Standard deviation of the normal distribution.
+    N : int, optional
+        Number of random samples to generate. Defaults to 1.
 
     Returns
     -------
-    N deviates from the normal distribution
-    
+    ndarray
+        NumPy array of length ``N`` containing random samples drawn from the
+        specified normal distribution. If ``N=1``, the returned array has shape
+        ``(1,)``.
+
+    Notes
+    -----
+    This function is a thin convenience wrapper around ``numpy.random.normal``.
+    Its primary purpose is to provide a default of ``N=1`` and to ensure that
+    the return value is always a NumPy array, even when generating a single
+    sample. Results will vary between runs unless a random seed is set using
+    ``np.random.seed()``.
+
     Examples
     --------
-    >>> pmag.gaussdev(5.5,1.2,6)
-    array([5.090856280215007, 3.305193918953536, 7.313490558588299,
-           5.412029315803913, 6.819820301799303, 7.632257251681613])
+    Generate six samples from a normal distribution with mean 5.5 and standard
+    deviation 1.2:
+
+    >>> np.random.seed(42)  # optional, for reproducibility
+    >>> pmag.gaussdev(5.5, 1.2, 6)
+    array([6.096056983613479, 5.334082838594578, 6.277226245720831,
+        7.327635827689631, 5.219015950331997, 5.219035651660984])
+
+    Generate a single sample:
+
+    >>> np.random.seed(42)
+    >>> pmag.gaussdev(5.5, 1.2, 1)
+    array([6.096056983613479])
     """
     return random.normal(mean, sigma, N)  # return gaussian deviate
-#
 
 
 def get_unf(N=100):
@@ -8398,7 +8269,7 @@ def sbar(Ss):
       0.002760033333333333,
       -4.933333333333345e-06])
     """
-    if type(Ss) == list:
+    if isinstance(Ss, list):
         Ss = np.array(Ss)
     npts = Ss.shape[0]
     Ss = Ss.transpose()
@@ -8750,48 +8621,6 @@ def dostilt(s, bed_az, bed_dip):
         Vrot.append([d, i])
     s_rot = doeigs_s(tau, Vrot)
     return s_rot
-#
-#
-
-
-def apseudo(Ss, ipar, sigma):
-    """
-    Depreciated: 9/14/2022
-    
-    Draw a bootstrap sample of Ss.
-    
-    Parameters
-    ----------
-    Ss : six element tensor as a list
-    ipar : boolean (True, False, or zero value)
-    sigma : sigma of Ss
-    
-    Returns
-    -------
-    BSs : array 
-        bootstrap sample of Ss
-        
-    Examples 
-    --------
-    >>> pmag.apseudo(np.array([2,2,1,6,1,1]),0,0)
-    array([1, 2, 1, 2, 2, 1])
-    """
-#
-    Ss = np.array(Ss)   # added 9/9/22 for consistency with other functions using the variable "Ss"
-    Is = random.randint(0, len(Ss) - 1, size=len(Ss))  # draw N random integers
-    #Ss = np.array(Ss)
-    if not ipar: # ipar == 0:
-        BSs = Ss[Is]
-    else:  # need to recreate measurement - then do the parametric stuffr
-        A, B = design(6)  # get the design matrix for 6 measurementsa
-        K, BSs = [], []
-        for k in range(len(Ss)):
-            K.append(np.dot(A, Ss[k][0:6]))
-        Pars = np.random.normal(K, sigma)
-        for k in range(len(Ss)):
-            BSs.append(np.dot(B, Pars[k]))
-    return np.array(BSs)
-#
 
 
 def sbootpars(Taus, Vs):
@@ -8894,8 +8723,43 @@ def sbootpars(Taus, Vs):
     bpars["v3_eta_dec"] = kpars["Edec"]
     bpars["v3_eta_inc"] = kpars["Einc"]
     return bpars
+
+
+def apseudo(Ss, ipar, sigma):
+    """
+    This function draws a bootstrap sample of Ss, for use in pmag.s_boot.
+
+    Parameters
+    ----------
+    Ss : six element tensor as a list
+    ipar : boolean (True, False, or zero value)
+    sigma : sigma of Ss
+
+    Returns
+    -------
+    BSs : array 
+        bootstrap sample of Ss
+
+    Examples 
+    --------
+    >>> pmag.apseudo(np.array([2,2,1,6,1,1]),0,0)
+    array([1, 2, 1, 2, 2, 1])
+    """
 #
-#
+    Ss = np.array(Ss)   # added 9/9/22 for consistency with other functions using the variable "Ss"
+    Is = random.randint(0, len(Ss) - 1, size=len(Ss))  # draw N random integers
+    
+    if not ipar: # ipar == 0:
+        BSs = Ss[Is]
+    else:  # need to recreate measurement - then do the parametric stuffr
+        A, B = design(6)  # get the design matrix for 6 measurementsa
+        K, BSs = [], []
+        for k in range(len(Ss)):
+            K.append(np.dot(A, Ss[k][0:6]))
+        Pars = np.random.normal(K, sigma)
+        for k in range(len(Ss)):
+            BSs.append(np.dot(B, Pars[k]))
+    return np.array(BSs)
 
 
 def s_boot(Ss, ipar=0, nb=1000):
@@ -10426,7 +10290,8 @@ def measurements_methods3(meas_data, noave,savelast=False):
         noave = 1
     else:
         noave = 0
-    if savelast:noave=0
+    if savelast:
+        noave=0
     version_num = get_version()
     seqnum = 0
     sids = get_specs(meas_data)
@@ -11192,7 +11057,7 @@ def get_samp_con():
             else:
                 Z = samp_con.split("-")[1]
                 samp_con = "7"
-        if samp_con.isdigit() == False or int(samp_con) > 7:
+        if not samp_con.isdigit() or int(samp_con) > 7:
             print("Try again\n ")
             samp_con = ""
     return samp_con, Z
@@ -11639,7 +11504,7 @@ def pseudo(DIs, random_seed=None):
        [-40, 150],
        [-45, 150]])
     """
-    if random_seed != None:
+    if random_seed is not None:
         np.random.seed(random_seed)
     Inds = np.random.randint(len(DIs), size=len(DIs))
     D = np.array(DIs)
@@ -11949,37 +11814,64 @@ def squish(incs, f):
 
 
 def unsquish(incs, f):
-    """
-    Returns 'unflattened' inclination, assuming factor, f and King (1955) formula: tan (I_o) = tan (I_f)/f.
+    r"""
+    Restore (``unsquish``) inclinations using the King (1955) inclination-shallowing
+    correction.
+
+    King (1955) described the relationship between the inclination of a specimen’s
+    magnetization (:math:`I_o`, the *observed* inclination) and the inclination of
+    the field in which the magnetization was acquired (:math:`I_f`) as:
+
+    .. math::
+
+       \tan(I_o) = f \, \tan(I_f)
+
+    where :math:`f` is the flattening factor (:math:`0 < f \le 1`). When
+    :math:`f < 1`, the observed inclination is shallower than the original field
+    inclination due to compaction-related flattening.
+
+    This function inverts King's equation to estimate the original inclination from
+    observed inclinations:
+
+    .. math::
+
+       \tan(I_f) = \frac{\tan(I_o)}{f}
 
     Parameters
     ----------
-    incs : array of inclination (I_f) data to unflatten
-    f : flattening factor
+    incs : array_like
+        One-dimensional list or NumPy array of observed inclinations (:math:`I_o`)
+        in degrees, typically measured from remanent magnetization directions.
+    f : float
+        Flattening factor (:math:`0 < f \le 1`). Values less than 1 indicate
+        inclination shallowing; smaller values correspond to stronger flattening.
 
     Returns
     -------
-    I_o :  array of inclinations after unflattening
-    
+    ndarray
+        NumPy array of ``unsquished_incs`` (restored inclinations) in degrees with
+        the same shape as ``incs``.
+
     Examples
     --------
-    >>> incs = [63.4,59.2,73.9,85,-49.1,70.7]
-    >>> np.round(pmag.unsquish(incs,.5),1)
-    array([ 75.9,  73.4,  81.8,  87.5, -66.6,  80.1])
-
-    >>> incs=np.loadtxt('data_files/unsquish/unsquish_example.dat')
-    >>> pmag.unsquish(incs,.5)
-    array([[-19.791612533135584,  38.94002937796913 ],
-       [  3.596453939529656,  35.75555908297152 ],
-       [ 11.677464698445519,  27.012196299111633],
-       [  0.399995126240053,  46.27631997468994 ],
-       [ 46.760422847350405,  39.080596252430965],
-       [ 48.64708345693855 ,  37.07969161240791 ],
-   ... 
+    Basic usage with a list of observed inclinations (degrees):
+
+    >>> incs = [63.4, 59.2, 73.9, 85.1, -49.1, 70.7]
+    >>> unsquished = pmag.unsquish(incs, 0.6)
+    >>> print(np.round(unsquished, 1))
+    [ 73.3  70.3  80.2  87.1 -62.5  78.1]
+
+    Loading inclinations from a data file where they are stored as the second column:
+
+    >>> directions = np.loadtxt('data_files/unsquish/unsquish_example.dat')
+    >>> incs = directions[:, 1]  # extract the inclination column
+    >>> unsquished = pmag.unsquish(incs, 0.61)
+    >>> print(np.round(unsquished[:5], 1))  # show first 5 results
+    [33.5 30.5 22.7 40.6 33.7]
     """
     incs = np.radians(incs)
-    I_o = np.tan(incs)/f  # divide tangent by flattening factor
-    return np.degrees(np.arctan(I_o))
+    unsquished_incs = np.tan(incs) / f
+    return np.degrees(np.arctan(unsquished_incs))
 
 
 def get_ts(ts):
@@ -12062,37 +11954,38 @@ def execute(st, **kwargs):
 
 def initialize_acceptance_criteria(**kwargs):
     """
-    initialize acceptance criteria with NULL values for thellier_gui and demag_gui
+    Initializes a dictionary of acceptance criteria with default null values.
 
-    acceptance criteria format is doctionaries:
+    This function is used by thellier_gui and demag_gui to set up the
+    criteria for accepting or rejecting paleomagnetic data at different
+    levels (specimen, sample, site, etc.).
 
-    acceptance_criteria={}
-        acceptance_criteria[crit]={}
-            acceptance_criteria[crit]['category']=
-            acceptance_criteria[crit]['criterion_name']=
-            acceptance_criteria[crit]['value']=
-            acceptance_criteria[crit]['threshold_type']
-            acceptance_criteria[crit]['decimal_points']
-
-   'category':
-       'DE-SPEC','DE-SAMP'..etc
-   'criterion_name':
-       MagIC name
-   'value':
-        a number (for 'regular criteria')
-        a string (for 'flag')
-        1 for True (if criteria is bullean)
-        0 for False (if criteria is bullean)
-        -999 means N/A
-   'threshold_type':
-       'low'for low threshold value
-       'high'for high threshold value
-        [flag1.flag2]: for flags
-        'bool' for boolean flags (can be 'g','b' or True/Flase or 1/0)
-   'decimal_points':
-       number of decimal points in rounding
-       (this is used in displaying criteria in the dialog box)
-       -999 means Exponent with 3 descimal points for floats and string for string
+    Returns
+    -------
+    dict
+        A dictionary where each key is a specific criterion name (e.g., 'specimen_n').
+        The value for each key is another dictionary containing the metadata for that
+        criterion, with the following structure:
+
+        'category' : str
+            The category of the criterion (e.g., 'DE-SPEC', 'DE-SAMP').
+        'criterion_name' : str
+            The MagIC name for the criterion.
+        'value' : int, float, or str
+            The threshold value for the criterion.
+            - Numerical value for standard criteria.
+            - String for a flag.
+            - 1 for True, 0 for False for boolean criteria.
+            - -999 indicates Not Applicable (N/A).
+        'threshold_type' : str or list
+            Specifies how the threshold is applied.
+            - 'low': A lower bound (the measured value must be greater).
+            - 'high': An upper bound (the measured value must be less).
+            - list of str (e.g., ['n', 'r']): A list of acceptable flag values.
+            - 'bool': A boolean flag.
+        'decimal_points' : int
+            The number of decimal points for rounding when displaying the value.
+            - A value of -999 formats floats with an exponent and 3 decimal places.
     """
     acceptance_criteria = {}
     # --------------------------------
@@ -12635,7 +12528,7 @@ def read_criteria_from_file(path, acceptance_criteria, **kwargs):
                     acceptance_criteria[crit]['value'] = False
 
             # criteria as flags
-            elif type(acceptance_criteria[crit]['threshold_type']) == list:
+            elif isinstance(acceptance_criteria[crit]['threshold_type'], list):
                 if str(rec[crit]) in acceptance_criteria[crit]['threshold_type']:
                     acceptance_criteria[crit]['value'] = str(rec[crit])
                 else:
@@ -12705,19 +12598,19 @@ def write_criteria_to_file(path, acceptance_criteria, **kwargs):
                     value_key = crit
 
         # fix True/False typoes
-                if type(acceptance_criteria[crit]["value"]) == str:
+                if isinstance(acceptance_criteria[crit]["value"], str):
                     if acceptance_criteria[crit]["value"] == "TRUE":
                         acceptance_criteria[crit]["value"] = "True"
                     if acceptance_criteria[crit]["value"] == "FALSE":
                         acceptance_criteria[crit]["value"] = "False"
-                if type(acceptance_criteria[crit]["value"]) == str:
+                if isinstance(acceptance_criteria[crit]["value"], str):
                     if acceptance_criteria[crit]["value"] != "-999" and acceptance_criteria[crit]['value'] != "":
                         rec[value_key] = acceptance_criteria[crit]['value']
-                elif type(acceptance_criteria[crit]["value"]) == int:
+                elif isinstance(acceptance_criteria[crit]["value"], int):
                     if acceptance_criteria[crit]["value"] != -999:
                         rec[value_key] = "%.i" % (
                             acceptance_criteria[crit]["value"])
-                    elif type(acceptance_criteria[crit]["value"]) == float:
+                    elif isinstance(acceptance_criteria[crit]["value"], float):
                         if float(acceptance_criteria[crit]["value"]) == -999:
                             continue
                 if 'decimal_points' in acceptance_criteria[crit] in list(acceptance_criteria[crit].keys()):
@@ -12729,7 +12622,7 @@ def write_criteria_to_file(path, acceptance_criteria, **kwargs):
                         # exec command
                 else:
                     rec[value_key] = str(acceptance_criteria[crit]["value"])
-                if type(acceptance_criteria[crit]["value"]) == bool:
+                if isinstance(acceptance_criteria[crit]["value"], bool):
                     rec[value_key] = str(acceptance_criteria[crit]["value"])
                 # need to make a list of these dictionaries
                 if 'data_model' in list(kwargs.keys()) and kwargs['data_model'] == 3:
@@ -13006,7 +12899,8 @@ def do_mag_map(date, lon_0=0, alt=0, file="", mod="cals10k",resolution='low'):
             gh.append(lmgh[2][i])
             if lmgh[1][i] != 0:
                 gh.append(lmgh[3][i])
-        while len(gh)<120:gh.append(0)
+        while len(gh)<120:
+            gh.append(0)
 
     for j in range(len(lats)):  # step through the latitudes
         for i in range(len(lons)):  # and the longitudes
@@ -13164,9 +13058,12 @@ def scalc_vgp_df(vgp_df, anti=0, rev=0, cutoff=180., kappa=0, n=0, spin=0, v=0,
     """
     vgp_df['delta'] = 90.-vgp_df.vgp_lat.values
     # filter by cutoff, kappa, and n if desired
-    if v: vgp_df = vgp_df[vgp_df.delta <= cutoff]
-    if mm97:vgp_df = vgp_df[vgp_df.dir_k >= kappa]
-    if n: vgp_df = vgp_df[vgp_df.dir_n_samples >= n]
+    if v: 
+        vgp_df = vgp_df[vgp_df.delta <= cutoff]
+    if mm97:
+        vgp_df = vgp_df[vgp_df.dir_k >= kappa]
+    if n:
+        vgp_df = vgp_df[vgp_df.dir_n_samples >= n]
     if spin:  # do transformation to pole
         Pvgps = vgp_df[['vgp_lon', 'vgp_lat']].values
         ppars = doprinc(Pvgps)
@@ -13178,7 +13075,8 @@ def scalc_vgp_df(vgp_df, anti=0, rev=0, cutoff=180., kappa=0, n=0, spin=0, v=0,
         vgp_df['vgp_lat'] = lats
         vgp_df['delta'] = 90.-vgp_df.vgp_lat
     if anti:
-        if verbose: print('flipping reverse')
+        if verbose: 
+            print('flipping reverse')
         vgp_rev = vgp_df[vgp_df.vgp_lat < 0]
         vgp_norm = vgp_df[vgp_df.vgp_lat >= 0]
         vgp_anti = vgp_rev
@@ -13801,7 +13699,7 @@ def find_CMDT_CR(Ahat,Tc,mhat12):
     for i in range(201):
             theta = i*np.pi/100
             
-            ylen = np.zeros(201);
+            ylen = np.zeros(201)
             phi = np.linspace(0,np.pi/2,201)
             for j in range(201):
                 y[0] = np.sin(phi[j])*np.cos(theta)*np.sqrt(Tc)/np.sqrt(D[0])
@@ -13810,7 +13708,7 @@ def find_CMDT_CR(Ahat,Tc,mhat12):
                 ylen[j] = np.linalg.norm(y)
                 
             idx = np.argsort(ylen)
-            phi0 = np.interp(1.0,ylen[idx],phi[idx]);
+            phi0 = np.interp(1.0,ylen[idx],phi[idx])
             y[0] = np.sin(phi0)*np.cos(theta)*np.sqrt(Tc)/np.sqrt(D[0])
             y[1] = np.sin(phi0)*np.sin(theta)*np.sqrt(Tc)/np.sqrt(D[1])
             y[2] = np.cos(phi0)*np.sqrt(Tc)/np.sqrt(D[2])