ratapi 0.0.0.dev10__cp313-cp313-win_amd64.whl

ratapi/examples/normal_reflectivity/DSPC_standard_layers.py

@@ -0,0 +1,210 @@
+"""An example of a standard layers model in RAT."""
+
+import pathlib
+
+import numpy as np
+
+import ratapi as RAT
+
+
+def DSPC_standard_layers():
+    """Calculate a standard Layers fit of a DSPC floating bilayer.
+
+    The sample consists of a DSPC bilayer, on a silane SAM on Silicon.
+    """
+    problem = RAT.Project(name="original_dspc_bilayer", model="standard layers", geometry="substrate/liquid")
+
+    # Set up the relevant parameters
+    problem.parameters.append(name="Oxide Thickness", min=5.0, value=19.54, max=60.0, fit=True)
+    problem.parameters.append(name="Oxide SLD", min=3.39e-06, value=3.39e-06, max=3.41e-06, fit=False)
+    problem.parameters.append(name="SAM Tails Thickness", min=15.0, value=22.66, max=35.0, fit=True)
+    problem.parameters.append(name="SAM Tails SLD", min=-5e-07, value=-4.01e-07, max=-3e-07, fit=False)
+    problem.parameters.append(name="SAM Tails Hydration", min=1.0, value=5.252, max=50.0, fit=True)
+    problem.parameters.append(name="SAM Roughness", min=1.0, value=5.64, max=15.0, fit=True)
+    problem.parameters.append(name="CW Thickness", min=10.0, value=17.12, max=28.0, fit=True)
+    problem.parameters.append(name="CW SLD", min=0.0, value=0.0, max=1e-09, fit=False)
+
+    problem.parameters.append(
+        name="SAM Heads Thickness",
+        min=5.0,
+        value=8.56,
+        max=17.0,
+        fit=True,
+        prior_type="gaussian",
+        mu=10.0,
+        sigma=2.0,
+    )
+    problem.parameters.append(name="SAM Heads SLD", min=1.0e-07, value=1.75e-06, max=2.0e-06, fit=False)
+    problem.parameters.append(
+        name="SAM Heads Hydration",
+        min=10.0,
+        value=45.45,
+        max=50.0,
+        fit=True,
+        prior_type="gaussian",
+        mu=30.0,
+        sigma=3.0,
+    )
+    problem.parameters.append(
+        name="Bilayer Heads Thickness",
+        min=7.0,
+        value=10.7,
+        max=17.0,
+        fit=True,
+        prior_type="gaussian",
+        mu=10.0,
+        sigma=2.0,
+    )
+    problem.parameters.append(name="Bilayer Heads SLD", min=5.0e-07, value=1.47e-06, max=1.5e-06, fit=False)
+    problem.parameters.append(name="Bilayer Roughness", min=2.0, value=6.014, max=15.0, fit=True)
+    problem.parameters.append(name="Bilayer Tails Thickness", min=14.0, value=17.82, max=22.0, fit=True)
+    problem.parameters.append(name="Bilayer Tails SLD", min=-5.0e-07, value=-4.61e-07, max=0.0, fit=False)
+    problem.parameters.append(name="Bilayer Tails Hydration", min=10.0, value=17.64, max=50.0, fit=True)
+    problem.parameters.append(name="Bilayer Heads Hydration", min=10.0, value=36.15, max=50.0, fit=True)
+    problem.parameters.append(name="CW Hydration", min=99.9, value=100.0, max=100.0, fit=False)
+    problem.parameters.append(name="Oxide Hydration", min=0.0, value=23.61, max=60.0, fit=True)
+
+    problem.parameters.set_fields(0, max=10)
+
+    # Group these into layers
+    problem.layers.append(
+        name="Oxide",
+        thickness="Oxide Thickness",
+        SLD="Oxide SLD",
+        roughness="Substrate Roughness",
+        hydration="Oxide Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="SAM Tails",
+        thickness="SAM Tails Thickness",
+        SLD="SAM Tails SLD",
+        roughness="SAM Roughness",
+        hydration="SAM Tails Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="SAM Heads",
+        thickness="SAM Heads Thickness",
+        SLD="SAM Heads SLD",
+        roughness="SAM Roughness",
+        hydration="SAM Heads Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="Central Water",
+        thickness="CW Thickness",
+        SLD="CW SLD",
+        roughness="Bilayer Roughness",
+        hydration="CW Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="Bilayer Heads",
+        thickness="Bilayer Heads Thickness",
+        SLD="Bilayer Heads SLD",
+        roughness="Bilayer Roughness",
+        hydration="Bilayer Heads Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="Bilayer Tails",
+        thickness="Bilayer Tails Thickness",
+        SLD="Bilayer Tails SLD",
+        roughness="Bilayer Roughness",
+        hydration="Bilayer Tails Hydration",
+        hydrate_with="bulk out",
+    )
+
+    # Make the bulk SLDs
+    del problem.bulk_in[0]
+    problem.bulk_in.append(name="Silicon", min=2.0e-06, value=2.073e-06, max=2.1e-06, fit=False)
+
+    del problem.bulk_out[0]
+    problem.bulk_out.append(name="D2O", min=5.50e-06, value=5.98e-06, max=6.4e-06, fit=True)
+    problem.bulk_out.append(name="SMW", min=1.0e-06, value=2.21e-06, max=4.99e-06, fit=True)
+
+    # Set the scalefactors - use one for each contrast
+    del problem.scalefactors[0]
+    problem.scalefactors.append(name="Scalefactor 1", min=0.05, value=0.10, max=0.2, fit=False)
+    problem.scalefactors.append(name="Scalefactor 2", min=0.05, value=0.15, max=0.2, fit=False)
+
+    # Now deal with the backgrounds
+    del problem.backgrounds[0]
+    del problem.background_parameters[0]
+    problem.background_parameters.append(
+        name="Background parameter D2O",
+        min=5.0e-10,
+        value=2.23e-06,
+        max=7.0e-06,
+        fit=True,
+    )
+    problem.background_parameters.append(
+        name="Background parameter SMW",
+        min=1.0e-10,
+        value=3.38e-06,
+        max=4.99e-06,
+        fit=True,
+    )
+
+    problem.backgrounds.append(name="D2O Background", type="constant", source="Background parameter D2O")
+    problem.backgrounds.append(name="SMW Background", type="constant", source="Background parameter SMW")
+
+    # Now add the data
+    data_path = pathlib.Path(__file__).parents[1] / "data"
+
+    d2o_dat = np.loadtxt(data_path / "DSPC_D2O.dat", delimiter=",")
+    problem.data.append(name="dspc_bil_D2O", data=d2o_dat)
+
+    smw_dat = np.loadtxt(data_path / "DSPC_SMW.dat", delimiter=",")
+    problem.data.append(name="dspc_bil_smw", data=smw_dat)
+
+    # Set the model
+    stack = [
+        "Oxide",
+        "SAM Tails",
+        "SAM Heads",
+        "Central Water",
+        "Bilayer Heads",
+        "Bilayer Tails",
+        "Bilayer Tails",
+        "Bilayer Heads",
+    ]
+
+    # Then make the two contrasts
+    problem.contrasts.append(
+        name="D2O",
+        bulk_in="Silicon",
+        bulk_out="D2O",
+        background="D2O Background",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        data="dspc_bil_D2O",
+        model=stack,
+    )
+
+    problem.contrasts.append(
+        name="SMW",
+        bulk_in="Silicon",
+        bulk_out="SMW",
+        background="SMW Background",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 2",
+        data="dspc_bil_smw",
+        model=stack,
+    )
+
+    controls = RAT.Controls()
+    problem, results = RAT.run(problem, controls)
+
+    return problem, results
+
+
+if __name__ == "__main__":
+    problem, results = DSPC_standard_layers()
+    RAT.plotting.plot_ref_sld(problem, results, True)

ratapi/examples/normal_reflectivity/__init__.py

@@ -0,0 +1 @@
+"""Examples of normal reflectivity calculations in RAT."""

ratapi/examples/normal_reflectivity/background_function.py

@@ -0,0 +1,16 @@
+"""A background function for an example."""
+
+import numpy as np
+
+
+def background_function(xdata, params):
+    """Return the background function for a given set of points in q."""
+    # Split up the params array
+    Ao = params[0]
+    k = params[1]
+    back_const = params[2]
+
+    # Make an exponential decay background
+    background = Ao * np.exp(-k * np.array(xdata)) + back_const
+
+    return background

ratapi/examples/normal_reflectivity/custom_XY_DSPC.py

@@ -0,0 +1,138 @@
+"""A custom XY model for a supported DSPC bilayer."""
+
+from math import sqrt
+
+import numpy as np
+from scipy.special import erf
+
+
+def custom_XY_DSPC(params, bulk_in, bulk_out, contrast):
+    """Calculate the continuous SLD of a supported DSPC bilayer using volume restricted distribution functions."""
+    # Split up the parameters
+    subRough = params[0]
+    oxideThick = params[1]
+    oxideHydration = params[2]
+    waterThick = params[3]
+    lipidAPM = params[4]
+    lipidCoverage = params[5]
+    bilayerRough = params[6]
+
+    # We are going to need our Neutron scattering cross-sections, plus the component volumes
+    # (the volumes are taken from Armen et al as usual).
+    # Define these first
+
+    # define all the neutron b's.
+    bc = 0.6646e-4  # Carbon
+    bo = 0.5843e-4  # Oxygen
+    bh = -0.3739e-4  # Hydrogen
+    bp = 0.513e-4  # Phosphorus
+    bn = 0.936e-4  # Nitrogen
+
+    # Now make the lipid groups
+    COO = (4 * bo) + (2 * bc)
+    GLYC = (3 * bc) + (5 * bh)
+    CH3 = (2 * bc) + (6 * bh)
+    PO4 = (1 * bp) + (4 * bo)
+    CH2 = (1 * bc) + (2 * bh)
+    CHOL = (5 * bc) + (12 * bh) + (1 * bn)
+
+    # Group these into heads and tails
+    heads = CHOL + PO4 + GLYC + COO
+    tails = (34 * CH2) + (2 * CH3)
+
+    # We need volumes for each. Use literature values
+    vHead = 319
+    vTail = 782
+
+    # Start making our sections. For each we are using a roughened Heaviside to describe our groups.
+    # We will make these as Volume Fractions (i.e. with a height of 1 for full occupancy),
+    # which we will correct later for hydration.
+
+    # Make an array of z values for our model
+    z = np.arange(0, 141)
+
+    # Make our Silicon substrate
+    vfSilicon, siSurf = make_layer(z, -25, 50, 1, subRough, subRough)
+
+    # Add the Oxide
+    vfOxide, oxSurface = make_layer(z, siSurf, oxideThick, 1, subRough, subRough)
+
+    # We fill in the water at the end, but there may be a hydration layer between the bilayer and the oxide,
+    # so we start the bilayer stack an appropriate distance away
+    watSurface = oxSurface + waterThick
+
+    # Now make the first lipid head group
+    # Work out the thickness
+    headThick = vHead / lipidAPM
+
+    # ... and make a box for the volume fraction (1 for now, we correct for coverage later)
+    vfHeadL, headLSurface = make_layer(z, watSurface, headThick, 1, bilayerRough, bilayerRough)
+
+    # ... also do the same for the tails
+    # We'll make both together, so the thickness will be twice the volume
+    tailsThick = (2 * vTail) / lipidAPM
+    vfTails, tailsSurf = make_layer(z, headLSurface, tailsThick, 1, bilayerRough, bilayerRough)
+
+    # Finally the upper head ...
+    vfHeadR, headSurface = make_layer(z, tailsSurf, headThick, 1, bilayerRough, bilayerRough)
+
+    # Making the model
+    # We've created the volume fraction profiles corresponding to each of the groups.
+    # We now convert them to SLDs, taking in account of the hydrations to scale the volume fractions
+
+    # 1. Oxide ...
+    vfOxide = vfOxide * (1 - oxideHydration)
+
+    # 2. Lipid ...
+    # Scale both the heads and tails according to overall coverage
+    vfTails = vfTails * lipidCoverage
+    vfHeadL = vfHeadL * lipidCoverage
+    vfHeadR = vfHeadR * lipidCoverage
+
+    # Some extra work to deal with head hydration, which we take to be an additional 30% always
+    vfHeadL = vfHeadL * 0.7
+    vfHeadR = vfHeadR * 0.7
+
+    # Make a total Volume Fraction across the whole interface
+    vfTot = vfSilicon + vfOxide + vfHeadL + vfTails + vfHeadR
+
+    # All the volume that's left, we will fill with water
+    vfWat = 1 - vfTot
+
+    # Now convert all the Volume Fractions to SLDs
+    sld_Value_Tails = tails / vTail
+    sld_Value_Head = heads / vHead
+
+    sldSilicon = vfSilicon * 2.073e-6
+    sldOxide = vfOxide * 3.41e-6
+
+    sldHeadL = vfHeadL * sld_Value_Head
+    sldHeadR = vfHeadR * sld_Value_Head
+    sldTails = vfTails * sld_Value_Tails
+    sldWat = vfWat * bulk_out[contrast]
+
+    # Put this all together
+    totSLD = sldSilicon + sldOxide + sldHeadL + sldTails + sldHeadR + sldWat
+
+    # Make the SLD array for output
+    SLD = np.column_stack((z, totSLD))
+
+    return SLD, subRough
+
+
+def make_layer(z, prevLaySurf, thickness, height, Sigma_L, Sigma_R):
+    """Produce a layer, with a defined thickness, height and roughness.
+
+    Each side of the layer has its own roughness value.
+    """
+    # Find the edges
+    left = prevLaySurf
+    right = prevLaySurf + thickness
+
+    # Make our heaviside
+    erf_left = erf((z - left) / (sqrt(2) * Sigma_L))
+    erf_right = erf((z - right) / (sqrt(2) * Sigma_R))
+
+    VF = np.array((0.5 * height) * (erf_left - erf_right))
+
+    return VF, right

ratapi/examples/normal_reflectivity/custom_bilayer_DSPC.py

@@ -0,0 +1,87 @@
+"""A custom layer model for a DSPC supported bilayer."""
+
+import numpy as np
+
+
+def custom_bilayer_DSPC(params, bulk_in, bulk_out, contrast):
+    """Calculate layer parameters for a DSPC supported bilayer.
+
+    This file accepts 3 vectors containing the values for params, bulk in and bulk out.
+    The final parameter is an index of the contrast being calculated.
+
+    The function should output a matrix of layer values, in the form...
+
+    Output = [thick 1, SLD 1, Rough 1, Percent Hydration 1, Hydrate how 1
+              ....
+              thick n, SLD n, Rough n, Percent Hydration n, Hydration how n]
+
+    The "hydrate how" parameter decides if the layer is hydrated with Bulk out or Bulk in phases.
+    Set to 1 for Bulk out, zero for Bulk in.
+    Alternatively, leave out hydration and just return...
+
+    Output = [thick 1, SLD 1, Rough 1,
+              ....
+              thick n, SLD n, Rough n]
+
+    The second output parameter should be the substrate roughness.
+    """
+    sub_rough = params[0]
+    oxide_thick = params[1]
+    oxide_hydration = params[2]
+    lipidAPM = params[3]
+    headHydration = params[4]
+    bilayerHydration = params[5]
+    bilayerRough = params[6]
+    waterThick = params[7]
+
+    # We have a constant SLD for the bilayer
+    oxide_SLD = 3.41e-6
+
+    # Now make the lipid layers
+    # Use known lipid volume and compositions to make the layers
+
+    # define all the neutron b's.
+    bc = 0.6646e-4  # Carbon
+    bo = 0.5843e-4  # Oxygen
+    bh = -0.3739e-4  # Hydrogen
+    bp = 0.513e-4  # Phosphorus
+    bn = 0.936e-4  # Nitrogen
+
+    # Now make the lipid groups
+    COO = (4 * bo) + (2 * bc)
+    GLYC = (3 * bc) + (5 * bh)
+    CH3 = (2 * bc) + (6 * bh)
+    PO4 = (1 * bp) + (4 * bo)
+    CH2 = (1 * bc) + (2 * bh)
+    CHOL = (5 * bc) + (12 * bh) + (1 * bn)
+
+    # Group these into heads and tails:
+    Head = CHOL + PO4 + GLYC + COO
+    Tails = (34 * CH2) + (2 * CH3)
+
+    # We need volumes for each. Use literature values:
+    vHead = 319
+    vTail = 782
+
+    # We use the volumes to calculate the SLDs
+    SLDhead = Head / vHead
+    SLDtail = Tails / vTail
+
+    # We calculate the layer thickness' from the volumes and the APM
+    headThick = vHead / lipidAPM
+    tailThick = vTail / lipidAPM
+
+    # Manually deal with hydration for layers in this example.
+    oxSLD = (oxide_hydration * bulk_out[contrast]) + ((1 - oxide_hydration) * oxide_SLD)
+    headSLD = (headHydration * bulk_out[contrast]) + ((1 - headHydration) * SLDhead)
+    tailSLD = (bilayerHydration * bulk_out[contrast]) + ((1 - bilayerHydration) * SLDtail)
+
+    # Make the layers
+    oxide = [oxide_thick, oxSLD, sub_rough]
+    water = [waterThick, bulk_out[contrast], bilayerRough]
+    head = [headThick, headSLD, bilayerRough]
+    tail = [tailThick, tailSLD, bilayerRough]
+
+    output = np.array([oxide, water, head, tail, tail, head])
+
+    return output, sub_rough