diff --git a/polymer_brushes/README.md b/polymer_brushes/README.md
index b46b50e..1d55aaf 100644
--- a/polymer_brushes/README.md
+++ b/polymer_brushes/README.md
@@ -10,4 +10,23 @@ interface where the interfacial volume can be approximated.
 Added by:
 Isaac Gresham
 
-Date: 24/03/2020
\ No newline at end of file
+Date: 24/03/2020
+
+
+# Maxent
+Added by:
+Andrew Nelson
+
+Date: 01/08/2023
+
+
+# numerical self-consistent field theory
+
+Adapts the public domain nSCFT code written for Refl1D by Paul Kienzle and Richard Sheridan.
+The work of Sheridan et al. should be cited if this code is used: https://doi.org/10.1021/acs.macromol.7b00639
+
+
+Added by:
+Isaac Gresham
+
+Date: 10/08/2023
\ No newline at end of file
diff --git a/polymer_brushes/SCF.py b/polymer_brushes/SCF.py
new file mode 100755
index 0000000..7db1d49
--- /dev/null
+++ b/polymer_brushes/SCF.py
@@ -0,0 +1,899 @@
+## This code was adapted from that of Paul Kienzle (NIST) and Richard Sheridan.
+## The original code was public domain.
+
+## The original code was designed for use with Refl1D.
+## Isaac Gresham modified it for compatability with refnx.
+
+## Further optimisations are required for nSCFT_VFP to be
+## compatible with
+
+from collections import OrderedDict
+import numpy as np
+from numpy.core.multiarray import correlate as old_correlate
+
+from scipy.interpolate import PchipInterpolator as Pchip
+from scipy.integrate import simps
+
+from refnx.reflect import Structure, Component, SLD, Slab
+from refnx.analysis import Parameters, Parameter, possibly_create_parameter
+
+LAMBDA_1 = 1.0 / 6.0  # always assume cubic lattice (1/6) for now
+LAMBDA_0 = 1.0 - 2.0 * LAMBDA_1
+# Use reverse order for LAMBDA_ARRAY if it is asymmetric since we are using
+# it with correlate().
+LAMBDA_ARRAY = np.array([LAMBDA_1, LAMBDA_0, LAMBDA_1])
+MINLAT = 25
+MINBULK = 5
+SQRT_PI = np.sqrt(np.pi)
+
+_SZdist_dict = OrderedDict()
+
+
+EPS = np.finfo(float).eps
+
+
+class nSCFT_VFP(Component):
+    def __init__(
+        self,
+        adsorbed_amount,
+        lattice_size,
+        polymerMW,
+        latticeMW,
+        chi,
+        chi_s,
+        pdi,
+        polymer_sld,
+        rough=1,
+        name="",
+        microslab_max_thickness=1,
+        dist_model=None,
+        clear_cache=False,
+    ):
+        """
+        Parameters
+        ----------
+        Adsorbed Amount : Parameter or float
+            The integral of the volume fraction profile, equivalent to the dry thickness
+
+        polymer_sld : SLD object or float
+            The scattering length density of the polymer component
+
+        chi : float
+            Flory-Huggins solvent interaction parameter
+
+        chi_s :
+            surface interaction parameter
+
+        l_lat :
+            real length per lattice site
+
+        mn : float
+            Number average molecular weight
+
+        m_lat : float
+            real mass per lattice segment
+
+        pdi : float
+            Dispersity (Polydispersity index). float >= 1. By default,
+            calculated using the schulz-zimm distribution
+
+        name : string
+            The name of the structural component. Useful for later introspeciton.
+
+        microslab_max_thickness : float
+            Maximum slab thickness when approximating the profile as a series of slabs.
+
+        rough : float
+            the (gaussian) roughness between slabs in the slab approximation of the profile
+
+        dist_model : function or None
+            The model used to turn the PDI paramter into a probability density function of chain lengths.
+            If none the SZdist model is used.
+
+        clear_cache : bool
+            If true, performs every nSCFT calculation from scratch. If false, uses the prior (cached)
+            position as the starting point of the simulation. When using gradient decent fitters,
+            settering clear_cache to False speeds up the process considerably. When Using evolution
+            based fitters, monte carlo methods, or manualy tuning, clear_cache should be set to True.
+
+        """
+        super(nSCFT_VFP, self).__init__()
+
+        self.clear_cache = clear_cache
+
+        self.name = name
+
+        if isinstance(polymer_sld, SLD):
+            self.polymer_sld = polymer_sld
+        else:
+            self.polymer_sld = SLD(polymer_sld)
+
+        if dist_model is None:
+            print("no dist model provided, using schulz-zimm distribution")
+            dist_model = SZdist
+
+        self.dist_model = dist_model
+
+        self.microslab_max_thickness = microslab_max_thickness
+
+        self.adsorbed_amount = possibly_create_parameter(
+            adsorbed_amount, name="%s - adsorbed amount" % name
+        )
+
+        self.lattice_size = possibly_create_parameter(
+            lattice_size, name="%s - lattice size" % name
+        )
+
+        self.polymerMW = possibly_create_parameter(
+            polymerMW, name="%s - polymer MW" % name
+        )
+
+        self.latticeMW = possibly_create_parameter(
+            latticeMW, name="%s - lattice MW" % name
+        )
+
+        self.chi = possibly_create_parameter(chi, name="%s - chi" % name)
+
+        self.chi_s = possibly_create_parameter(chi_s, name="%s - chi substrate" % name)
+
+        self.pdi = possibly_create_parameter(
+            pdi, name="%s - polydispersity index" % name
+        )
+
+        self.rough = possibly_create_parameter(rough, name="%s - roughness" % name)
+
+    def __call__(self, z):
+        """
+        Calculates the volume fraction profile of the spline
+
+        Parameters
+        ----------
+        z : float
+            Distance along vfp
+
+        Returns
+        -------
+        vfp : float
+            Volume fraction
+        """
+        vfp = SCFprofile(
+            z,
+            chi=self.chi.value,
+            chi_s=self.chi_s.value,
+            h_dry=self.adsorbed_amount.value,
+            l_lat=self.lattice_size.value,
+            mn=self.polymerMW.value,
+            m_lat=self.latticeMW.value,
+            pdi=self.pdi.value,
+            dist_model=self.dist_model,
+            clear_cache=self.clear_cache,
+        )
+        return vfp
+
+    def moment(self, moment=1):
+        """
+        Calculates the n'th moment of the profile
+
+        Parameters
+        ----------
+        moment : int
+            order of moment to be calculated
+
+        Returns
+        -------
+        moment : float
+            n'th moment
+        """
+        zed, profile = self.profile()
+        profile *= zed**moment
+        val = simps(profile, zed)
+        area = self.profile_area()
+        return val / area
+
+    def is_monotonic(self):
+        return np.all(self.dzf.pvals < 1)
+
+    @property
+    def parameters(self):
+        p = Parameters(name=self.name)
+        p.extend(
+            [
+                self.adsorbed_amount,
+                self.chi,
+                self.chi_s,
+                self.polymer_sld.parameters,
+                self.lattice_size,
+                self.polymerMW,
+                self.latticeMW,
+                self.pdi,
+                self.rough,
+            ]
+        )
+        return p
+
+    def lnprob(self):
+        return 0
+
+    def profile_area(self, bounds=[0, 2000]):
+        """
+        Calculates integrated area of volume fraction profile
+
+        Returns
+        -------
+        area: integrated area of volume fraction profile
+        """
+
+        z = np.linspace(*bounds, 10000)
+
+        return np.trapz(self(z), z)
+
+    def slabs(self, structure=None):
+        slab_extent = (
+            self.lattice_size.value * self.polymerMW.value / self.latticeMW.value
+        )
+        num_slabs = np.ceil(float(slab_extent) / self.microslab_max_thickness)
+        slab_thick = float(slab_extent / num_slabs)
+        slabs = np.zeros((int(num_slabs), 5))
+        slabs[:, 0] = slab_thick
+
+        # give last slab a miniscule roughness so it doesn't get contracted
+        slabs[-1:, 3] = 0.5
+
+        dist = np.cumsum(slabs[..., 0]) - 0.5 * slab_thick
+
+        slabs[:, 1] = self.polymer_sld.real.value
+        slabs[:, 2] = self.polymer_sld.imag.value
+        slabs[:, 4] = 1 - self(dist)
+
+        slabs[0:, 3] = self.rough.value
+
+        return slabs
+
+    def profile(self):
+        """
+        Calculates the volume fraction profile
+
+        Returns
+        -------
+        z, vfp : np.ndarray
+            Distance from the interface, volume fraction profile
+        """
+        s = Structure()
+        s |= SLD(0)
+
+        m = SLD(1.0)
+
+        for i, slab in enumerate(self.left_slabs):
+            layer = m(slab.thick.value, slab.rough.value)
+            if not i:
+                layer.rough.value = 0
+            layer.vfsolv.value = slab.vfsolv.value
+            s |= layer
+
+        polymer_slabs = self.slabs()
+        offset = np.sum(s.slabs()[:, 0])
+
+        for i in range(np.size(polymer_slabs, 0)):
+            layer = m(polymer_slabs[i, 0], polymer_slabs[i, 3])
+            layer.vfsolv.value = polymer_slabs[i, -1]
+            s |= layer
+
+        for i, slab in enumerate(self.right_slabs):
+            layer = m(slab.thick.value, slab.rough.value)
+            layer.vfsolv.value = 1 - slab.vfsolv.value
+            s |= layer
+
+        s |= SLD(0, 0)
+
+        # now calculate the VFP.
+        total_thickness = np.sum(s.slabs()[:, 0])
+        if total_thickness < 500:
+            num_zed_points = int(total_thickness)
+        else:
+            num_zed_points = 500
+        zed = np.linspace(0, total_thickness, num_zed_points)
+        # SLD profile puts a very small roughness on the interfaces with zero
+        # roughness.
+        zed[0] = 0.01
+        z, s = s.sld_profile(z=zed)
+        s[0] = s[1]
+
+        return z, s
+
+
+def SZdist(pdi, nn, cache=_SZdist_dict):
+    """Calculate Shultz-Zimm distribution from PDI and number average DP
+
+    Shultz-Zimm is a "realistic" distribution for linear polymers. Numerical
+    problems arise when the distribution gets too uniform, so if we find them,
+    default to an exact uniform calculation.
+    """
+    from scipy.special import gammaln
+
+    args = pdi, nn
+    if args in cache:
+        cache[args] = cache.pop(args)
+        return cache[args]
+
+    uniform = False
+
+    if pdi == 1.0:
+        uniform = True
+    elif pdi < 1.0:
+        raise ValueError("Invalid PDI")
+    else:
+        x = 1.0 / (pdi - 1.0)
+        # Calculate the distribution in chunks so we don't waste CPU time
+        chunk = 256
+        p_ni_list = []
+        pdi_underflow = False
+
+        for i in range(max(1, int((100 * nn) / chunk))):
+            ni = np.arange(chunk * i + 1, chunk * (i + 1) + 1, dtype=np.float64)
+            r = ni / nn
+            xr = x * r
+
+            p_ni = np.exp(np.log(x / ni) - gammaln(x + 1) + xr * (np.log(xr) / r - 1))
+
+            pdi_underflow = (p_ni >= 1.0).any()  # catch "too small PDI"
+            if pdi_underflow:
+                break  # and break out to uniform calculation
+
+            # Stop calculating when species account for less than 1ppm
+            keep = (r < 1.0) | (p_ni >= 1e-6)
+            if keep.all():
+                p_ni_list.append(p_ni)
+            else:
+                p_ni_list.append(p_ni[keep])
+                break
+        else:  # Belongs to the for loop. Executes if no break statement runs.
+            raise RuntimeError("SZdist overflow")
+
+    if uniform or pdi_underflow:
+        # NOTE: rounding here allows nn to be a double in the rest of the np.logic
+        p_ni = np.zeros(int(round(nn)))
+        p_ni[-1] = 1.0
+    else:
+        p_ni = np.concatenate(p_ni_list)
+        p_ni /= p_ni.sum()
+    cache[args] = p_ni
+
+    if len(cache) > 9000:
+        cache.popitem(last=False)
+
+    return p_ni
+
+
+def SCFprofile(
+    z,
+    chi=None,
+    chi_s=None,
+    h_dry=None,
+    l_lat=1,
+    mn=None,
+    m_lat=1,
+    phi_b=0,
+    pdi=1,
+    disp=False,
+    dist_model=SZdist,
+    clear_cache=False,
+):
+    """
+    Polymer end-tethered to an interface in a solvent.
+    Generate volume fraction profile for Refl1D based on real parameters.
+
+    The field theory is a lattice-based one, so we need to move between lattice
+    and real space. This is done using the parameters l_lat and m_lat, the
+    lattice size and the mass of a lattice segment, respectivley. We use h_dry
+    (dry thickness) as a convenient measure of surface coverage, along with mn
+    (number average molecular weight) as the real inputs.
+
+    Make sure your inputs for h_dry/l_lat and mn/m_lat match dimensions!
+    Angstroms and daltons are good choices.
+
+    Uses a numerical self-consistent field profile.\ [#Cosgrove]_\ [#deVos]_\ [#Sheridan]_
+
+    **Parameters**
+        *chi*
+            solvent interaction parameter
+        *chi_s*
+            surface interaction parameter
+        *h_dry*
+            thickness of the neat polymer layer
+        *l_lat*
+            real length per lattice site
+        *mn*
+            Number average molecular weight
+        *m_lat*
+            real mass per lattice segment
+        *pdi*
+            Dispersity (Polydispersity index)
+        *phi_b*
+            volume fraction of free chains in solution. useful for associating
+            grafted films e.g. PS-COOH in Toluene with an SiO2 surface.
+
+
+    Previous layer should not have roughness! Use a spline to simulate it.
+
+    According to [#Vincent]_, $l_\text{lat}$ and $m_\text{lat}$ should be
+    calculated by the formulas:
+
+    .. math::
+
+        l_\text{lat} &= \frac{a^2 m/l}{p_l} \\
+        m_\text{lat} &= \frac{(a m/l)^2}{p_l}
+
+    where $l$ is the real polymer's bond length, $m$ is the real segment mass,
+    and $a$ is the ratio between molecular weight and radius of gyration at
+    theta conditions. The lattice persistence, $p_l$, is:
+
+    .. math::
+
+        p_l = \frac16 \frac{1+1/Z}{1-1/Z}
+
+    with coordination number $Z = 6$ for a cubic lattice, $p_l = .233$.
+
+    """
+
+    # calculate lattice space parameters
+    theta = h_dry / l_lat
+    segments = mn / m_lat
+    sigma = theta / segments
+
+    # solve the self consistent field equations using the cache
+    if disp:
+        print("\n=====Begin calculations=====\n")
+
+    if clear_cache:
+        phi_lat = SCFcache(
+            chi,
+            chi_s,
+            pdi,
+            sigma,
+            phi_b,
+            segments,
+            dist_model,
+            disp,
+            cache=OrderedDict(),
+        )
+    else:
+        phi_lat = SCFcache(chi, chi_s, pdi, sigma, phi_b, segments, dist_model, disp)
+
+    if disp:
+        print("\n============================\n")
+
+    # Chop edge effects out
+    for x, layer in enumerate(reversed(phi_lat)):
+        if abs(layer - phi_b) < 1e-6:
+            break
+    phi_lat = phi_lat[: -(x + 1)]
+
+    # re-dimensionalize the solution
+    layers = len(phi_lat)
+    z_end = l_lat * layers
+    z_lat = np.linspace(0.0, z_end, num=layers)
+    phi = np.interp(z, z_lat, phi_lat, right=phi_b)
+
+    return phi
+
+
+_SCFcache_dict = OrderedDict()
+
+
+def SCFcache(
+    chi,
+    chi_s,
+    pdi,
+    sigma,
+    phi_b,
+    segments,
+    dist_model,
+    disp=False,
+    cache=_SCFcache_dict,
+):
+    """Return a memoized SCF result by walking from a previous solution.
+
+    Using an OrderedDict because I want to prune keys FIFO
+    """
+    from scipy.optimize.nonlin import NoConvergence
+
+    # prime the cache with a known easy solutions
+    if not cache:
+        cache[(0, 0, 0, 0.1, 0.1, 0.1)] = SCFsolve(
+            sigma=0.1, phi_b=0.1, segments=50, disp=disp
+        )
+        cache[(0, 0, 0, 0, 0.1, 0.1)] = SCFsolve(
+            sigma=0, phi_b=0.1, segments=50, disp=disp
+        )
+        cache[(0, 0, 0, 0.1, 0, 0.1)] = SCFsolve(
+            sigma=0.1, phi_b=0, segments=50, disp=disp
+        )
+
+    if disp:
+        starttime = time()
+
+    # Try to keep the parameters between 0 and 1. Factors are arbitrary.
+    scaled_parameters = (chi, chi_s * 3, pdi - 1, sigma, phi_b, segments / 500)
+
+    # longshot, but return a cached result if we hit it
+    if scaled_parameters in cache:
+        if disp:
+            print("SCFcache hit at:", scaled_parameters)
+        phi = cache[scaled_parameters] = cache.pop(scaled_parameters)
+        return phi
+
+    # Find the closest parameters in the cache: O(len(cache))
+
+    # Numpy setup
+    cached_parameters = tuple(dict.__iter__(cache))
+    cp_array = np.array(cached_parameters)
+    p_array = np.array(scaled_parameters)
+
+    # Calculate distances to all cached parameters
+    deltas = p_array - cp_array  # Parameter space displacement vectors
+    closest_index = np.sum(deltas * deltas, axis=1).argmin()
+
+    # Organize closest point data for later use
+    closest_cp = cached_parameters[closest_index]
+    closest_cp_array = cp_array[closest_index]
+    closest_delta = deltas[closest_index]
+
+    phi = cache[closest_cp] = cache.pop(closest_cp)
+
+    if disp:
+        print("Walking from nearest:", closest_cp_array)
+        print("to:", p_array)
+
+    """
+    We must walk from the previously cached point to the desired region.
+    This is goes from step=0 (cached) and step=1 (finish), where the step=0
+    is implicit above. We try the full step first, so that this function only
+    calls SCFsolve one time during normal cache misses.
+
+    The solver may not converge if the step size is too big. In that case,
+    we retry with half the step size. This should find the edge of the basin
+    of attraction for the solution eventually. On successful steps we increase
+    stepsize slightly to accelerate after getting stuck.
+
+    It might seem to make sense to bin parameters into a coarser grid, so we
+    would be more likely to have cache hits and use them, but this rarely
+    happened in practice.
+    """
+
+    step = 1.0  # Fractional distance between cached and requested
+    dstep = 1.0  # Step size increment
+    flag = True
+
+    while flag:
+        # end on 1.0 exactly every time
+        if step >= 1.0:
+            step = 1.0
+            flag = False
+
+        # conditional math because, "why risk floating point error"
+        if flag:
+            p_tup = tuple(closest_cp_array + step * closest_delta)
+        else:
+            p_tup = scaled_parameters
+
+        if disp:
+            print("Parameter step is", step)
+            print("current parameters:", p_tup)
+
+        try:
+            phi = SCFsolve(
+                p_tup[0],
+                p_tup[1] / 3,
+                p_tup[2] + 1,
+                p_tup[3],
+                p_tup[4],
+                p_tup[5] * 500,
+                disp=disp,
+                phi0=phi,
+                dist_model=dist_model,
+            )
+        except (NoConvergence, ValueError) as e:
+            if isinstance(e, ValueError):
+                if str(e) != "array must not contain infs or NaNs":
+                    raise
+            if disp:
+                print("Step failed")
+            flag = True  # Reset this so we don't quit if step=1.0 fails
+            dstep *= 0.5
+            step -= dstep
+            if dstep < 1e-5:
+                raise RuntimeError("Cache walk appears to be stuck")
+        else:  # Belongs to try, executes if no exception is raised
+            cache[p_tup] = phi
+            dstep *= 1.05
+            step += dstep
+
+    if disp:
+        print("SCFcache execution time:", round(time() - starttime, 3), "s")
+
+    # keep the cache from consuming all things
+    while len(cache) > 100:
+        cache.popitem(last=False)
+
+    return phi
+
+
+def SCFsolve(
+    chi=0,
+    chi_s=0,
+    pdi=1,
+    sigma=None,
+    phi_b=0,
+    segments=None,
+    disp=False,
+    phi0=None,
+    maxiter=30,
+    dist_model=SZdist,
+):
+    """Solve SCF equations using an initial guess and lattice parameters
+
+    This function finds a solution for the equations where the lattice size
+    is sufficiently large.
+
+    The Newton-Krylov solver really makes this one. With gmres, it was faster
+    than the other solvers by quite a lot.
+    """
+
+    from scipy.optimize import newton_krylov
+
+    if sigma >= 1:
+        raise ValueError("Chains that short cannot be squeezed that high")
+
+    if disp:
+        starttime = time()
+
+    # print ('segments: ', segments, 'pdi: ', pdi)
+
+    p_i = dist_model(pdi, segments)
+    # print ('len dist: ', len(p_i))
+
+    if phi0 is None:
+        # TODO: Better initial guess for chi>.6
+        phi0 = default_guess(segments, sigma)
+        if disp:
+            print("No guess passed, using default phi0: layers =", len(phi0))
+    else:
+        phi0 = abs(phi0)
+        phi0[phi0 > 0.99999] = 0.99999
+        if disp:
+            print("Initial guess passed: layers =", len(phi0))
+
+    # resizing loop variables
+    jac_solve_method = "gmres"
+    lattice_too_small = True
+
+    # We tolerate up to 1 ppm deviation from bulk phi
+    # when counting layers_near_phi_b
+    tol = 1e-6
+
+    def curried_SCFeqns(phi):
+        return SCFeqns(phi, chi, chi_s, sigma, segments, p_i, phi_b)
+
+    while lattice_too_small:
+        if disp:
+            print("Solving SCF equations")
+
+        try:
+            with np.errstate(invalid="ignore"):
+                phi = abs(
+                    newton_krylov(
+                        curried_SCFeqns,
+                        phi0,
+                        verbose=bool(disp),
+                        maxiter=maxiter,
+                        method=jac_solve_method,
+                    )
+                )
+        except RuntimeError as e:
+            if str(e) == "gmres is not re-entrant":
+                # Threads are racing to use gmres. Lose the race and use
+                # something slower but thread-safe.
+                jac_solve_method = "lgmres"
+                continue
+            else:
+                raise
+
+        if disp:
+            print("lattice size:", len(phi))
+
+        phi_deviation = abs(phi - phi_b)
+        layers_near_phi_b = phi_deviation < tol
+        nbulk = np.sum(layers_near_phi_b)
+        lattice_too_small = nbulk < MINBULK
+
+        if lattice_too_small:
+            # if there aren't enough layers_near_phi_b, grow the lattice 20%
+            newlayers = max(1, round(len(phi0) * 0.2))
+            if disp:
+                print("Growing undersized lattice by", newlayers)
+            if nbulk:
+                i = np.diff(layers_near_phi_b).nonzero()[0].max()
+            else:
+                i = phi_deviation.argmin()
+            phi0 = np.insert(phi, i, np.linspace(phi[i - 1], phi[i], num=newlayers))
+
+    if nbulk > 2 * MINBULK:
+        chop_end = np.diff(layers_near_phi_b).nonzero()[0].max()
+        chop_start = chop_end - MINBULK
+        i = np.arange(len(phi))
+        phi = phi[(i <= chop_start) | (i > chop_end)]
+
+    if disp:
+        print("SCFsolve execution time:", round(time() - starttime, 3), "s")
+
+    return phi
+
+
+def default_guess(segments=100, sigma=0.5, phi_b=0.1, chi=0, chi_s=0):
+    """Produce an initial guess for phi via analytical approximants.
+
+    For now, a line using numbers from scaling theory
+    """
+    ss = np.sqrt(sigma)
+    default_layers = int(round(max(MINLAT, segments * ss)))
+    default_phi0 = np.linspace(ss, phi_b, num=default_layers)
+    return default_phi0
+
+
+def SCFeqns(phi_z, chi, chi_s, sigma, n_avg, p_i, phi_b=0):
+    """System of SCF equation for terminally attached polymers.
+
+    Formatted for input to a nonlinear minimizer or solver.
+
+    The sign convention here on u is "backwards" and always has been.
+    It saves a few sign flips, and looks more like Cosgrove's.
+    """
+
+    # let the solver go negative if it wants
+    phi_z = abs(phi_z)
+
+    # penalize attempts that overfill the lattice
+    toomuch = phi_z > 0.99999
+    penalty_flag = toomuch.any()
+    if penalty_flag:
+        penalty = np.where(toomuch, phi_z - 0.99999, 0)
+        phi_z[toomuch] = 0.99999
+
+    # calculate new g_z (Boltzmann weighting factors)
+    u_prime = np.log((1.0 - phi_z) / (1.0 - phi_b))
+    u_int = 2 * chi * (old_correlate(phi_z, LAMBDA_ARRAY, 1) - phi_b)
+    u_int[0] += chi_s
+    u_z = u_prime + u_int
+    g_z = np.exp(u_z)
+
+    # normalize g_z for numerical stability
+    u_z_avg = np.mean(u_z)
+    g_z_norm = g_z / np.exp(u_z_avg)
+
+    phi_z_new = calc_phi_z(g_z_norm, n_avg, sigma, phi_b, u_z_avg, p_i)
+
+    eps_z = phi_z - phi_z_new
+
+    if penalty_flag:
+        np.copysign(penalty, eps_z, penalty)
+        eps_z += penalty
+
+    return eps_z
+
+
+def calc_phi_z(g_z, n_avg, sigma, phi_b, u_z_avg=0, p_i=None):
+    if p_i is None:
+        segments = n_avg
+        uniform = True
+    else:
+        segments = p_i.size
+        uniform = segments == round(n_avg)
+
+    g_zs = Propagator(g_z, segments)
+
+    # for terminally attached chains
+    if sigma:
+        g_zs_ta = g_zs.ta()
+
+        if uniform:
+            c_i_ta = sigma / np.sum(g_zs_ta[:, -1])
+            g_zs_ta_ngts = g_zs.ngts_u(c_i_ta)
+        else:
+            c_i_ta = sigma * p_i / np.sum(g_zs_ta, axis=0)
+            g_zs_ta_ngts = g_zs.ngts(c_i_ta)
+
+        phi_z_ta = compose(g_zs_ta, g_zs_ta_ngts, g_z)
+    else:
+        phi_z_ta = 0
+
+    # for free chains
+    if phi_b:
+        g_zs_free = g_zs.free()
+
+        if uniform:
+            r_i = segments
+            c_free = phi_b / r_i
+            normalizer = np.exp(u_z_avg * r_i)
+            c_free = c_free * normalizer
+            g_zs_free_ngts = g_zs.ngts_u(c_free)
+        else:
+            r_i = np.arange(1, segments + 1)
+            c_i_free = phi_b * p_i / r_i
+            normalizer = np.exp(u_z_avg * r_i)
+            c_i_free = c_i_free * normalizer
+            g_zs_free_ngts = g_zs.ngts(c_i_free)
+
+        phi_z_free = compose(g_zs_free, g_zs_free_ngts, g_z)
+    else:
+        phi_z_free = 0
+
+    return phi_z_ta + phi_z_free
+
+
+def compose(g_zs, g_zs_ngts, g_z):
+    prod = g_zs * np.fliplr(g_zs_ngts)
+    prod[np.isnan(prod)] = 0
+    return np.sum(prod, axis=1) / g_z
+
+
+class Propagator(object):
+    def __init__(self, g_z, segments):
+        self.g_z = g_z
+        self.shape = int(g_z.size), int(segments)
+
+    def ta(self):
+        # terminally attached beginnings
+        # forward propagator
+
+        g_zs = self._new()
+        g_zs[:, 0] = 0.0
+        g_zs[0, 0] = self.g_z[0]
+        _calc_g_zs_uniform(self.g_z, g_zs, LAMBDA_0, LAMBDA_1)
+        return g_zs
+
+    def free(self):
+        # free beginnings
+        # forward propagator
+
+        g_zs = self._new()
+        g_zs[:, 0] = self.g_z
+        _calc_g_zs_uniform(self.g_z, g_zs, LAMBDA_0, LAMBDA_1)
+        return g_zs
+
+    def ngts_u(self, c):
+        # free ends of uniform chains
+        # reverse propagator
+
+        g_zs = self._new()
+        g_zs[:, 0] = c * self.g_z
+        _calc_g_zs_uniform(self.g_z, g_zs, LAMBDA_0, LAMBDA_1)
+        return g_zs
+
+    def ngts(self, c_i):
+        # free ends of disperse chains
+        # reverse propagator
+
+        g_zs = self._new()
+        g_zs[:, 0] = c_i[-1] * self.g_z
+        _calc_g_zs(self.g_z, c_i, g_zs, LAMBDA_0, LAMBDA_1)
+        return g_zs
+
+    def _new(self):
+        return np.empty(self.shape, order="F")
+
+
+def _calc_g_zs(g_z, c_i, g_zs, f0, f1):
+    coeff = np.array([f1, f0, f1])
+    pg_zs = g_zs[:, 0]
+    segment_iterator = enumerate(c_i[::-1])
+    next(segment_iterator)
+    for r, c in segment_iterator:
+        g_zs[:, r] = pg_zs = (old_correlate(pg_zs, coeff, 1) + c) * g_z
+
+
+def _calc_g_zs_uniform(g_z, g_zs, f0, f1):
+    coeff = np.array([f1, f0, f1])
+    segments = g_zs.shape[1]
+    pg_zs = g_zs[:, 0]
+    for r in range(1, segments):
+        g_zs[:, r] = pg_zs = old_correlate(pg_zs, coeff, 1) * g_z
diff --git a/polymer_brushes/SCFexample.ipynb b/polymer_brushes/SCFexample.ipynb
new file mode 100644
index 0000000..2f357b9
--- /dev/null
+++ b/polymer_brushes/SCFexample.ipynb
@@ -0,0 +1,296 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "25fe2c7e-aa9a-4465-b370-2f13f3f78be4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from SCF import SCFprofile, SZdist, nSCFT_VFP\n",
+    "\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from refnx.reflect import SLD, Slab, ReflectModel, MixedReflectModel\n",
+    "from refnx.dataset import ReflectDataset as RD\n",
+    "from refnx.analysis import (\n",
+    "    Objective,\n",
+    "    CurveFitter,\n",
+    "    PDF,\n",
+    "    Parameter,\n",
+    "    Parameters,\n",
+    "    process_chain,\n",
+    "    load_chain,\n",
+    "    GlobalObjective,\n",
+    ")\n",
+    "from refnx.reflect import Exponential, Linear, Spline\n",
+    "\n",
+    "import sys\n",
+    "\n",
+    "sys.path.append(\"./../../refnxtoolbox/\")\n",
+    "\n",
+    "import plottools"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b701c0e2-1f88-4f4b-b6b0-490bacd3e545",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Fitting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4806068a-924b-46bf-b184-c35e40b6e862",
+   "metadata": {},
+   "source": [
+    "According to Vincent et al., $l_\\text{lat}$ and $m_\\text{lat}$ should be\n",
+    "calculated by the formulas:\n",
+    "\n",
+    "\n",
+    "$$l_\\mathrm{lat} = \\frac{a^2 m/l}{p_l}$$\n",
+    "\n",
+    "$$m_\\text{lat} = \\frac{(a m/l)^2}{p_l}$$\n",
+    "\n",
+    "\n",
+    "where $l$ is the real polymer's bond length, $m$ is the real segment mass,\n",
+    "and $a$ is the ratio between molecular weight and radius of gyration at\n",
+    "theta conditions. The lattice persistence, $p_l$, is:\n",
+    "\n",
+    "$$p_l = \\frac16 \\frac{1+1/Z}{1-1/Z}$$\n",
+    "\n",
+    "with coordination number $Z = 6$ for a cubic lattice, $p_l = .233$.\n",
+    "\n",
+    "for PNIPAM, $m=114\\ \\rm{Da}$  and  $l\\approx2.5\\ \\rm{Å}$ (assuming a C-C bond length is $1.53\\ \\rm{Å}$ and the bond angle is $111.7\\ ˚$)\n",
+    "\n",
+    "I don't know what $a$ is though. attempts to calculated it from literature confuse me. \n",
+    "\n",
+    "As this is just an example, I'm using a persistance length of 10 repeat units for PNIPAM. Very approximate calcs yeild:\n",
+    "\n",
+    "$$l_\\text{lat} = 15\\ \\rm{Å}$$\n",
+    "$$m_\\text{lat} = 1100\\ \\rm{Da}$$\n",
+    "\n",
+    "Vincent, B., Edwards, J., Emmett, S., & Croot, R. (1988).\n",
+    "    Phase separation in dispersions of weakly-interacting particles in\n",
+    "    solutions of non-adsorbing polymer. Colloids and Surfaces, 31, 267–298.\n",
+    "    doi:10.1016/0166-6622(88)80200-2\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ab3283f7-894e-44ae-8316-dcd5257cce95",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = RD(\"pNIPAM brush in d2o at 25C.dat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ddee9d38-f3c8-4151-a29d-be4b549f8175",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Si = SLD(2.07, \"Silicon\")\n",
+    "SiO2 = SLD(3.47, \"Silica\")\n",
+    "D2O = SLD(6.3, \"D2O\")\n",
+    "PNIPAM = SLD(0.9, \"PNIPAM\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "18023c04-5f7a-4928-920a-150a606ff00d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "no dist model provided, using schulz-zimm distribution\n"
+     ]
+    }
+   ],
+   "source": [
+    "silica_layer = SiO2(15)\n",
+    "silica_layer.thick.setp(value=15, bounds=(10, 20), vary=True)\n",
+    "silica_layer.vfsolv.setp(value=0.1, bounds=(0, 0.15), vary=True)\n",
+    "silica_layer.rough.setp(value=2, bounds=(1, 4), vary=True)\n",
+    "\n",
+    "\n",
+    "sPNIPAM_layer = nSCFT_VFP(\n",
+    "    adsorbed_amount=120,\n",
+    "    lattice_size=15,\n",
+    "    polymerMW=200000,\n",
+    "    latticeMW=1100,\n",
+    "    pdi=1.3,\n",
+    "    polymer_sld=PNIPAM,\n",
+    "    chi=0,\n",
+    "    chi_s=2.2,\n",
+    "    name=\"PDMS VFP\",\n",
+    ")\n",
+    "\n",
+    "sPNIPAM_layer.adsorbed_amount.setp(90, 150)\n",
+    "sPNIPAM_layer.pdi.setp(bounds=(1.01, 1.5), vary=True)\n",
+    "sPNIPAM_layer.chi.setp(bounds=(-0.2, 0.8), vary=True)\n",
+    "sPNIPAM_layer.chi_s.setp(bounds=(0.5, 3), vary=True)\n",
+    "sPNIPAM_layer.polymerMW.setp(bounds=(30000, 500000), vary=True)\n",
+    "\n",
+    "\n",
+    "D2O_layer = D2O(0)\n",
+    "\n",
+    "D2O_structure_PDMS = Si | silica_layer | sPNIPAM_layer | D2O_layer\n",
+    "D2O_structure_PDMS.name = \"D2O\"\n",
+    "\n",
+    "\n",
+    "D2Omodel = ReflectModel(D2O_structure_PDMS)\n",
+    "D2Omodel.bkg.setp(value=1e-6, bounds=(5e-7, 1e-5), vary=True)\n",
+    "\n",
+    "D2Oobj = Objective(D2Omodel, data, name=\"D$_2$O\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8a2bc69c-b8ad-4f95-9879-40d2c5ca3a69",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/isaac/Documents/GitHub/refnx-models/polymer_brushes/SCF.py:816: RuntimeWarning: overflow encountered in multiply\n",
+      "  g_zs[:, r] = pg_zs = old_correlate(pg_zs, coeff, 1) * g_z\n",
+      "/Users/isaac/miniconda3/lib/python3.10/site-packages/numpy/core/fromnumeric.py:86: RuntimeWarning: overflow encountered in reduce\n",
+      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, [__, ax1, ax2] = plottools.graph_plot(\n",
+    "    objective=D2Oobj,\n",
+    "    color=plt.cm.plasma,\n",
+    "    offset=1e-1,\n",
+    "    ystyle=\"rq4\",\n",
+    "    xstyle=\"log\",\n",
+    "    vf_plot=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "05809897-5856-4265-ab51-8a563360dabf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fitter = CurveFitter(D2Oobj)\n",
+    "fitter.fit(\"least_squares\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b868dd4a-70e9-4e86-af01-6be21307030b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, [__, ax1, ax2] = plottools.graph_plot(\n",
+    "    objective=D2Oobj,\n",
+    "    color=plt.cm.plasma,\n",
+    "    offset=1e-1,\n",
+    "    ystyle=\"rq4\",\n",
+    "    xstyle=\"log\",\n",
+    "    vf_plot=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7a34373f-e719-4bd7-bedb-5a7bf2db94a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<Parameter:     'bkg'     , value=4.43631e-06 +/- 2.73e-07, bounds=[5e-07, 1e-05]>\n",
+      "<Parameter:'Silica - thick', value=19.3919 +/- 3.81 , bounds=[10.0, 20.0]>\n",
+      "<Parameter:'Silica - rough', value=4  +/- 5.3 , bounds=[1.0, 4.0]>\n",
+      "<Parameter:'Silica - volfrac solvent', value=1.90943e-08 +/- 0.149, bounds=[0.0, 0.15]>\n",
+      "<Parameter:'PDMS VFP - adsorbed amount', value=70.5814 +/- 1.27 , bounds=[-inf, inf]>\n",
+      "<Parameter:'PDMS VFP - chi', value=0.146751 +/- 0.08 , bounds=[-0.2, 0.8]>\n",
+      "<Parameter:'PDMS VFP - chi substrate', value=2.96736 +/- 1.59 , bounds=[0.5, 3.0]>\n",
+      "<Parameter:'PDMS VFP - polymer MW', value=182498 +/- 2.26e+04, bounds=[30000.0, 500000.0]>\n",
+      "<Parameter:'PDMS VFP - polydispersity index', value=1.20442 +/- 0.0281, bounds=[1.01, 1.5]>\n"
+     ]
+    }
+   ],
+   "source": [
+    "for x in D2Oobj.varying_parameters():\n",
+    "    print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0598b7e5-5fbc-45f6-a205-c8748490601d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}