Another try

Author: StephenNneji

RATapi/examples/domains/alloyDomains.m

@@ -0,0 +1,29 @@
+
+function [output,subRough] = alloyDomains(params,bulkIn,bulkOut,contrast,domain)
+
+% Simple custom model for testing incoherent summing...
+% Simple two layer of permalloy / gold, with up/down domains..
+
+% Split up the parameters....
+subRough = params(1);
+alloyThick = params(2);
+alloySLDup = params(3);
+alloySLDdn = params(4);
+alloyRough = params(5);
+goldThick = params(6);
+goldSLD = params(7);
+goldRough = params(8);
+
+% Make the layers....
+alloyUp = [alloyThick, alloySLDup, alloyRough];
+alloyDn = [alloyThick, alloySLDdn, alloyRough];
+gold = [goldThick, goldSLD, goldRough];
+
+% Make the model dependiong on which domain we are looking at..
+if domain==1
+    output = [alloyUp ; gold];
+else
+    output = [alloyDn ; gold];
+end
+
+end

RATapi/examples/domains/domains_custom_layers.py

@@ -30,8 +30,8 @@ def domains_custom_layers():
     # Add the custom file
     problem.custom_files.append(
         name="Alloy domains",
-        filename="alloy_domains.py",
-        language="python",
+        filename="alloyDomains.m",
+        language="matlab",
         path=pathlib.Path(__file__).parent.resolve(),
     )
 

RATapi/examples/normal_reflectivity/DSPC_function_background.py

@@ -146,8 +146,8 @@ def DSPC_function_background():
 
     problem.custom_files.append(
         name="D2O Background Function",
-        filename="background_function.py",
-        language="python",
+        filename="backgroundFunction.m",
+        language="matlab",
         path=pathlib.Path(__file__).parent.resolve(),
     )
 

RATapi/examples/normal_reflectivity/backgroundFunction.m

@@ -0,0 +1,14 @@
+function background = backgroundFunction(xdata,params)
+
+% Split up the params array....
+Ao = params(1);
+k = params(2);
+backConst = params(3);
+
+% Make an exponential decay background....
+background = zeros(numel(xdata),1);
+for i = 1:numel(xdata)
+    background(i) = Ao*exp(-k*xdata(i)) + backConst;
+end
+
+end

RATapi/examples/normal_reflectivity/customBilayerDSPC.m

@@ -0,0 +1,86 @@
+function [output,sub_rough] = customBilayerDSPC(params,bulk_in,bulk_out,contrast)
+%CUSTOMBILAYER  RASCAL Custom Layer Model File.
+%
+%
+% 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 m-file 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(1);
+oxide_thick = params(2);
+oxide_hydration = params(3);
+lipidAPM = params(4);
+headHydration = params(5);
+bilayerHydration = params(6);
+bilayerRough = params(7);
+waterThick = params(8);
+
+
+% 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
+bd = 0.6671e-4;     %Deuterium
+
+% 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 SLD's
+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 = [oxide ; water ; head ; tail ; tail ; head];
+
+
+

RATapi/wrappers.py

@@ -3,6 +3,7 @@
 import pathlib
 import platform
 import shutil
+import subprocess
 from typing import Callable
 
 import numpy as np
@@ -14,33 +15,39 @@
 MATLAB_PATH_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)), "matlab.txt")
 
 
-def set_matlab_path(path):
-    if not path:
+def set_matlab_path(matlab_path):
+    if not matlab_path:
         return 
 
-    path = pathlib.Path(path)
-    if not path.is_dir():
-        path = path.parent
+    if platform.system() == "Windows": 
+        process = subprocess.Popen(f'"{matlab_path}" -batch "comserver(\'register\')"')
+        process.wait()
+        
+
+    with open(MATLAB_PATH_FILE, "w") as path_file:
+        path_file.write(matlab_path)
 
-    if path.stem != 'bin':
-        path = path / 'bin'
 
+def get_matlab_paths(exe_path):
+    if not exe_path:
+        raise FileNotFoundError()
+    
+    bin_path = pathlib.Path(exe_path).parent
+    if bin_path.stem != 'bin':
+        raise FileNotFoundError()
+    
     if platform.system() == "Windows": 
         arch  = "win64"
     elif  platform.system() == "Darwin":
-        arch = "maci64" if (path / "maci64").exists() else "maca64"
+        arch = "maci64" if (bin_path / "maci64").exists() else "maca64"
     else: 
         arch = "glnxa64"
 
-    path = path / arch
-    if not path.exists():
-        raise FileNotFoundError(f"The expected MATLAB folders were in found at the path: {path}")
-    
-    with open(MATLAB_PATH_FILE, "w") as path_file:
-        path_file.write(path.as_posix())
-
-    return path.as_posix()
+    dll_path = bin_path / arch
+    if not dll_path.exists():
+        raise FileNotFoundError(f"The expected MATLAB folders were in found at the path: {dll_path}")
 
+    return f'{bin_path.as_posix()}/' , f'{dll_path.as_posix()}/'
 
 def start_matlab():
     """Start MATLAB asynchronously and returns a future to retrieve the engine later.
@@ -58,19 +65,25 @@ def start_matlab():
         matlab_path = ""
 
     if not matlab_path:
-        matlab_path = set_matlab_path(shutil.which("matlab"))
+        matlab_path = shutil.which("matlab")
         if matlab_path is None:
             matlab_path = ""
-            
-    if matlab_path: 
-        os.environ["PATH"] += os.pathsep + matlab_path
+        else:
+            temp = pathlib.Path(matlab_path)
+            if temp.is_symlink():
+                matlab_path = temp.readlink().as_posix()
+            set_matlab_path(matlab_path)
+    
+    if matlab_path:
+        bin_path, dll_path = get_matlab_paths(matlab_path)
+        os.environ["MATLAB_DLL_PATH"] = dll_path
+        os.environ["PATH"] = bin_path + os.pathsep + os.environ["PATH"]
+        os.environ["PATH"] = dll_path + os.pathsep + os.environ["PATH"]
         engine = RATapi.rat_core.MatlabEngine()
-        engine.start()
 
         return engine
 
 
-
 class MatlabWrapper:
     """Creates a python callback for a MATLAB function.