ratapi 0.0.0.dev16__cp315-cp315-win_amd64.whl

ratapi/examples/domains/domains_XY_model.py

@@ -0,0 +1,75 @@
+"""Custom model file for the domains custom XY example."""
+
+from math import sqrt
+
+import numpy as np
+from scipy.special import erf
+
+
+def domains_XY_model(params, bulk_in, bulk_out, contrast, domain):
+    """Calculate the SLD profile for a domains custom XY model."""
+    # Note - The first contrast number is 1 (not 0) so be careful if you use
+    # this variable for array indexing. Same applies to the domain number.
+
+    # Split up the parameters for convenience
+    subRough = params[0]
+    oxideThick = params[1]
+    layerThick = params[2]
+    layerSLD = params[3]
+    layerRough = params[4]
+    domainSLD = params[5]
+
+    # Make an array of z values for our model
+    z = np.arange(0, 141)
+
+    # Make the volume fraction distribution for our Silicon substrate
+    [vfSilicon, siSurf] = make_layer(z, -25, 50, 1, subRough, subRough)
+
+    # ... and the Oxide ...
+    [vfOxide, oxSurface] = make_layer(z, siSurf, oxideThick, 1, subRough, subRough)
+
+    # ... and also our layer.
+    [vfLayer, laySurface] = make_layer(z, oxSurface, layerThick, 1, subRough, layerRough)
+
+    # Everything that is not already occupied will be filled will water
+    totalVF = vfSilicon + vfOxide + vfLayer
+    vfWater = 1 - totalVF
+
+    # Now convert the Volume Fractions to SLDs
+    siSLD = vfSilicon * bulk_in[contrast - 1]
+    oxSLD = vfOxide * 3.41e-6
+
+    # Layer SLD depends on whether we are calculating the domain or not
+    if domain == 1:
+        laySLD = vfLayer * layerSLD
+    elif domain == 2:
+        laySLD = vfLayer * domainSLD
+
+    # ... and finally the water SLD.
+    waterSLD = vfWater * bulk_out[contrast - 1]
+
+    # Make the total SLD by just adding them all up
+    totalSLD = siSLD + oxSLD + laySLD + waterSLD
+
+    # The output is just a [n x 2] array of z against SLD
+    SLD = np.column_stack([z, totalSLD])
+
+    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/domains/domains_custom_XY.py

@@ -0,0 +1,86 @@
+"""An example of using domains with a Custom XY model."""
+
+import pathlib
+
+import ratapi as RAT
+
+
+def domains_custom_XY():
+    """Calculate an example of a layer containing domains using a custom XY model.
+
+    Domains custom XY models operate in the same way as domains custom layer models,
+    in that there is an additional input to the custom model
+    specifying the domain to be calculated.
+
+    This is then used within the function to calculate the correct SLD profile
+    for each contrast and domain. In this example, we simulate a hydrogenated layer
+    on a silicon substrate, containing domains of a larger SLD, against D2O, SMW and water.
+    """
+    problem = RAT.Project(calculation="domains", model="custom xy", geometry="substrate/liquid")
+
+    problem.parameters.append(name="Oxide Thickness", min=10.0, value=20.0, max=50.0, fit=True)
+    problem.parameters.append(name="Layer Thickness", min=1.0, value=30.0, max=500.0, fit=True)
+    problem.parameters.append(name="Layer SLD", min=-0.5e-6, value=-0.5e-6, max=0.0, fit=True)
+    problem.parameters.append(name="Layer Roughness", min=2.0, value=5.0, max=7.0, fit=True)
+    problem.parameters.append(name="Domain SLD", min=1.0e-6, value=1.0e-6, max=5.0e-6, fit=True)
+
+    problem.bulk_in.set_fields(0, name="Silicon", value=2.073e-6, max=1.0, fit=False)
+    problem.scalefactors.set_fields(0, min=0.8, value=1.0, max=1.1, fit=True)
+
+    problem.bulk_out.append(name="SLD SMW", min=2.0e-6, value=2.073e-6, max=2.1e-6)
+    problem.bulk_out.append(name="SLD H2O", min=-0.6e-6, value=-0.56e-6, max=-0.5e-6)
+
+    # Add the custom file
+    problem.custom_files.append(
+        name="Domain Layer",
+        filename="domains_XY_model.py",
+        language="python",
+        path=pathlib.Path(__file__).parent,
+    )
+
+    # Make contrasts
+    problem.contrasts.append(
+        name="D2O",
+        background="Background 1",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        bulk_in="Silicon",
+        bulk_out="SLD D2O",
+        domain_ratio="Domain Ratio 1",
+        data="Simulation",
+        model=["Domain Layer"],
+    )
+
+    problem.contrasts.append(
+        name="SMW",
+        background="Background 1",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        bulk_in="Silicon",
+        bulk_out="SLD SMW",
+        domain_ratio="Domain Ratio 1",
+        data="Simulation",
+        model=["Domain Layer"],
+    )
+
+    problem.contrasts.append(
+        name="H2O",
+        background="Background 1",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        bulk_in="Silicon",
+        bulk_out="SLD H2O",
+        domain_ratio="Domain Ratio 1",
+        data="Simulation",
+        model=["Domain Layer"],
+    )
+
+    controls = RAT.Controls()
+    problem, results = RAT.run(problem, controls)
+
+    return problem, results
+
+
+if __name__ == "__main__":
+    problem, results = domains_custom_XY()
+    RAT.plotting.plot_ref_sld(problem, results, True)

ratapi/examples/domains/domains_custom_layers.py

@@ -0,0 +1,60 @@
+"""An example of using domains with custom layer models."""
+
+import pathlib
+
+import ratapi as RAT
+
+
+def domains_custom_layers():
+    """Calculate an example custom layers domains project involving incoherent summing on a permalloy layer.
+
+    For a custom layers model, rather than being forced to define our layers as [Thick SLD Rough…. etc],
+    we can parameterise however we like and then use a function to calculate the parameters for each layer.
+    So for example, if the volume of lipid tails are known (from the literature),
+    then all we need is the Area per molecule to calculate the layers.
+    """
+    problem = RAT.Project(calculation="domains", model="custom layers", geometry="substrate/liquid")
+
+    # Make some parameters...
+    problem.parameters.append(name="Alloy Thickness", min=100.0, value=150.0, max=200.0, fit=True)
+    problem.parameters.append(name="Alloy SLD up", min=9.0e-6, value=11.0e-6, max=13.0e-6, fit=True)
+    problem.parameters.append(name="Alloy SLD down", min=5.0e-6, value=7.0e-6, max=10.0e-6, fit=True)
+    problem.parameters.append(name="Alloy Roughness", min=5.0, value=7.0, max=11.0, fit=True)
+    problem.parameters.append(name="Gold Thickness", min=100.0, value=150.0, max=200.0, fit=True)
+    problem.parameters.append(name="Gold SLD", min=4.0e-6, value=4.5e-6, max=5.0e-6, fit=True)
+    problem.parameters.append(name="Gold Roughness", min=5.0, value=7.0, max=11.0, fit=True)
+
+    # Set the bulk SLD
+    problem.bulk_in.set_fields(0, name="Silicon", value=2.073e-6, max=1.0)
+
+    # Add the custom file
+    problem.custom_files.append(
+        name="Alloy domains",
+        filename="alloy_domains.py",
+        language="python",
+        path=pathlib.Path(__file__).parent,
+    )
+
+    # Make a contrast
+    problem.contrasts.append(
+        name="D2O Contrast",
+        data="Simulation",
+        background="Background 1",
+        bulk_in="Silicon",
+        bulk_out="SLD D2O",
+        scalefactor="Scalefactor 1",
+        resolution="Resolution 1",
+        resample=False,
+        domain_ratio="Domain Ratio 1",
+        model=["Alloy domains"],
+    )
+
+    controls = RAT.Controls()
+    problem, results = RAT.run(problem, controls)
+
+    return problem, results
+
+
+if __name__ == "__main__":
+    problem, results = domains_custom_layers()
+    RAT.plotting.plot_ref_sld(problem, results, True)

ratapi/examples/domains/domains_standard_layers.py

@@ -0,0 +1,92 @@
+"""An example using domains with standard layers."""
+
+import ratapi as RAT
+
+
+def domains_standard_layers():
+    """Calculate an example for using standard layers with domains.
+
+    Domains standard layers projects proceed in much the same way as a normal standard layers problem,
+    except that there is an additional grouping step between layers and contrasts.
+
+    Layers are grouped into ‘Domain Contrasts’. The model for the actual experimental contrast
+    is built from these domain contrasts rather than from layers. There are exactly
+    two domains for each contrast, with the the ratio of them controlled by
+    a fittable ‘domain ratio’ parameter.
+    """
+    problem = RAT.Project(calculation="domains")
+
+    # Define the parameters we need to define our two domains
+    problem.parameters.append(name="L1 Thickness", min=5.0, value=20.0, max=60.0, fit=True)
+    problem.parameters.append(name="L1 SLD", min=3.0e-6, value=4.1e-6, max=5.0e-6, fit=False)
+    problem.parameters.append(name="L1 Roughness", min=2.0, value=5.0, max=20.0, fit=True)
+    problem.parameters.append(name="L1 Hydration", min=10.0, value=20.0, max=30.0, fit=True)
+
+    problem.parameters.append(name="L2 Thickness", min=5.0, value=60.0, max=100.0, fit=True)
+    problem.parameters.append(name="L2 SLD", min=2.1e-6, value=3.0e-6, max=5.0e-6, fit=False)
+    problem.parameters.append(name="L2 Roughness", min=2.0, value=5.0, max=20.0, fit=True)
+    problem.parameters.append(name="L2 Hydration", min=10.0, value=20.0, max=30.0, fit=True)
+
+    problem.parameters.append(name="L3 Thickness", min=5.0, value=200.0, max=300.0, fit=True)
+    problem.parameters.append(name="L3 SLD", min=3.0e-6, value=7.0e-6, max=8.0e-6, fit=False)
+    problem.parameters.append(name="L3 Roughness", min=2.0, value=5.0, max=20.0, fit=True)
+    problem.parameters.append(name="L3 Hydration", min=10.0, value=20.0, max=30.0, fit=True)
+
+    # Now group these parameters into layers
+    problem.layers.append(
+        name="Layer 1",
+        thickness="L1 Thickness",
+        SLD="L1 SLD",
+        roughness="L1 Roughness",
+        hydration="L1 Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="Layer 2",
+        thickness="L2 Thickness",
+        SLD="L2 SLD",
+        roughness="L2 Roughness",
+        hydration="L2 Hydration",
+        hydrate_with="bulk out",
+    )
+
+    problem.layers.append(
+        name="Layer 3",
+        thickness="L3 Thickness",
+        SLD="L3 SLD",
+        roughness="L3 Roughness",
+        hydration="L3 Hydration",
+        hydrate_with="bulk out",
+    )
+
+    # If we look at the project, there are two extra groups as compared to a normal standard layers calculation:
+    # Domain Contrasts and Domain Ratios
+    problem.domain_contrasts.append(name="Domain 1", model=["Layer 1"])
+    problem.domain_contrasts.append(name="Domain 2", model=["Layer 2", "Layer 3"])
+
+    # Now make a contrast as with standard models, but this time also including the default domain ratio
+    # ("Domain Ratio 1")
+    problem.contrasts.append(
+        name="Domain Test",
+        background="Background 1",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        resample=False,
+        bulk_in="SLD Air",
+        bulk_out="SLD D2O",
+        domain_ratio="Domain Ratio 1",
+        data="Simulation",
+        model=["Domain 1", "Domain 2"],
+    )
+
+    # Now we can run our simulation as usual
+    controls = RAT.Controls()
+    problem, results = RAT.run(problem, controls)
+
+    return problem, results
+
+
+if __name__ == "__main__":
+    problem, results = domains_standard_layers()
+    RAT.plotting.plot_ref_sld(problem, results, True)

ratapi/examples/languages/__init__.py

@@ -0,0 +1 @@
+"""A benchmark for using RAT custom files in three different languages."""

ratapi/examples/languages/custom_bilayer.py

@@ -0,0 +1,72 @@
+"""A custom bilayer model for the custom file languages benchmark."""
+
+import numpy as np
+
+
+def custom_bilayer(params, bulk_in, bulk_out, contrast):
+    """Calculate the layer parameters for a custom bilayer model."""
+    # Note - The first contrast number is 1 (not 0) so be careful if you use
+    # this variable for array indexing.
+
+    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]) + ((1 - oxide_hydration) * oxide_SLD)
+    headSLD = (headHydration * bulk_out[contrast - 1]) + ((1 - headHydration) * SLDhead)
+    tailSLD = (bilayerHydration * bulk_out[contrast - 1]) + ((1 - bilayerHydration) * SLDtail)
+
+    # Make the layers
+    oxide = [oxide_thick, oxSLD, sub_rough]
+    water = [waterThick, bulk_out[contrast - 1], bilayerRough]
+    head = [headThick, headSLD, bilayerRough]
+    tail = [tailThick, tailSLD, bilayerRough]
+
+    output = np.array([oxide, water, head, tail, tail, head])
+
+    return output, sub_rough

ratapi/examples/languages/run_custom_file_languages.py

@@ -0,0 +1,41 @@
+"""Test custom function languages."""
+
+import pathlib
+import time
+
+import setup_problem
+
+import ratapi as RAT
+
+path = pathlib.Path(__file__).parent
+
+project = setup_problem.make_example_problem()
+controls = RAT.Controls()
+
+# Python
+start = time.time()
+project, results = RAT.run(project, controls)
+end = time.time()
+print(f"Python time is: {end - start}s\n")
+
+RAT.plotting.plot_ref_sld(project, results)
+
+# Matlab
+project.custom_files.set_fields(0, filename="custom_bilayer.m", language="matlab", path=path)
+
+start = time.time()
+project, results = RAT.run(project, controls)
+end = time.time()
+print(f"Matlab time is: {end - start}s\n")
+
+RAT.plotting.plot_ref_sld(project, results)
+
+# C++
+project.custom_files.set_fields(0, filename="custom_bilayer.dll", language="cpp", path=path)
+
+start = time.time()
+project, results = RAT.run(project, controls)
+end = time.time()
+print(f"C++ time is: {end - start}s\n")
+
+RAT.plotting.plot_ref_sld(project, results)

ratapi/examples/languages/setup_problem.py

@@ -0,0 +1,130 @@
+"""A custom example problem for the languages benchmark."""
+
+import pathlib
+
+import numpy as np
+
+import ratapi as RAT
+
+
+def make_example_problem():
+    """Generate a Custom Layers example for Supported DSPC layer.
+
+    Example of using custom layers to model a DSPC supported bilayer.
+    """
+    problem = RAT.Project(name="Orso lipid example - custom layers", model="custom layers", geometry="substrate/liquid")
+
+    # First we need to set up a parameters group. We will be using a pre-prepared custom model file, so we need to add
+    # the relevant parameters we are going to need to define the model (note that Substrate Roughness always exists as
+    # parameter 1).
+    problem.parameters.append(name="Oxide Thickness", min=5.0, value=20.0, max=60.0, fit=True)
+    problem.parameters.append(name="Oxide Hydration", min=0.0, value=0.2, max=0.5, fit=True)
+    problem.parameters.append(name="Lipid APM", min=45.0, value=55.0, max=65.0, fit=True)
+    problem.parameters.append(name="Head Hydration", min=00.0, value=0.2, max=0.5, fit=True)
+    problem.parameters.append(name="Bilayer Hydration", min=0.0, value=0.1, max=0.2, fit=True)
+    problem.parameters.append(name="Bilayer Roughness", min=2.0, value=4.0, max=8.0, fit=True)
+    problem.parameters.append(name="Water Thickness", min=0.0, value=2.0, max=10.0, fit=True)
+
+    problem.parameters.set_fields(0, min=1.0, max=10.0)
+
+    # Need to add the relevant Bulk SLDs.
+    # Change the bulk in from air to silicon, and add two additional water contrasts:
+    problem.bulk_in.set_fields(0, name="Silicon", min=2.07e-6, value=2.073e-6, max=2.08e-6, fit=False)
+
+    problem.bulk_out.append(name="SLD SMW", min=1.0e-6, value=2.073e-6, max=3.0e-6, fit=True)
+    problem.bulk_out.append(name="SLD H2O", min=-0.6e-6, value=-0.56e-6, max=-0.3e-6, fit=True)
+
+    problem.bulk_out.set_fields(0, min=5.0e-6, fit=True)
+
+    # Now add the datafiles. We have three datasets we need to consider - the bilayer against D2O, Silicon Matched Water
+    # and H2O. Load these datafiles in and put them in the data block
+
+    # Read in the datafiles
+    data_path = pathlib.Path(__file__).parents[1] / "data"
+    D2O_data = np.loadtxt(data_path / "c_PLP0016596.dat", delimiter=",")
+    SMW_data = np.loadtxt(data_path / "c_PLP0016601.dat", delimiter=",")
+    H2O_data = np.loadtxt(data_path / "c_PLP0016607.dat", delimiter=",")
+
+    # Add the data to the project - note this data has a resolution 4th column
+    problem.data.append(name="Bilayer / D2O", data=D2O_data)
+    problem.data.append(name="Bilayer / SMW", data=SMW_data)
+    problem.data.append(name="Bilayer / H2O", data=H2O_data)
+
+    # Add the custom file to the project
+    problem.custom_files.append(
+        name="DSPC Model",
+        filename="custom_bilayer.py",
+        language="python",
+        path=pathlib.Path(__file__).parent,
+    )
+
+    # Also, add the relevant background parameters - one each for each contrast:
+    problem.background_parameters.set_fields(
+        0,
+        name="Background parameter D2O",
+        fit=True,
+        min=1.0e-10,
+        max=1.0e-5,
+        value=1.0e-07,
+    )
+
+    problem.background_parameters.append(
+        name="Background parameter SMW",
+        min=1.0e-10,
+        value=1.0e-7,
+        max=1.0e-5,
+        fit=True,
+    )
+    problem.background_parameters.append(
+        name="Background parameter H2O",
+        min=1.0e-10,
+        value=1.0e-7,
+        max=1.0e-5,
+        fit=True,
+    )
+
+    # And add the two new constant backgrounds
+    problem.backgrounds.append(name="Background SMW", type="constant", source="Background parameter SMW")
+    problem.backgrounds.append(name="Background H2O", type="constant", source="Background parameter H2O")
+
+    # And edit the other one
+    problem.backgrounds.set_fields(0, name="Background D2O", source="Background parameter D2O")
+
+    # Finally modify some of the other parameters to be more suitable values for a solid / liquid experiment
+    problem.scalefactors.set_fields(0, value=1.0, min=0.5, max=2.0, fit=True)
+
+    # Now add the three contrasts
+    problem.contrasts.append(
+        name="Bilayer / D2O",
+        background="Background D2O",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        bulk_out="SLD D2O",
+        bulk_in="Silicon",
+        data="Bilayer / D2O",
+        model=["DSPC Model"],
+    )
+
+    problem.contrasts.append(
+        name="Bilayer / SMW",
+        background="Background SMW",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        bulk_out="SLD SMW",
+        bulk_in="Silicon",
+        data="Bilayer / SMW",
+        model=["DSPC Model"],
+    )
+
+    problem.contrasts.append(
+        name="Bilayer / H2O",
+        background="Background H2O",
+        resolution="Resolution 1",
+        scalefactor="Scalefactor 1",
+        bulk_out="SLD H2O",
+        bulk_in="Silicon",
+        data="Bilayer / H2O",
+        model=["DSPC Model"],
+    )
+
+    return problem