def __init__(self, bkg, name, dq, threads, quad_order):
self.name = name
self.threads = threads
self.quad_order = quad_order
self._bkg = possibly_create_parameter(bkg, name='bkg')
# we can optimize the resolution (but this is always overridden by
# x_err if supplied. There is therefore possibly no dependence on it.
self._dq = possibly_create_parameter(dq, name='dq - resolution')
def __init__(self, gamma, vf, dz, polymer_sld, name='',
left_slabs=(), right_slabs=(),
interpolator=Pchip, zgrad=True, monotonic_penalty=0,
microslab_max_thickness=1):
self.name = name
self.gamma = (
possibly_create_parameter(gamma,
name='%s - adsorbed amount' % name))
if isinstance(polymer_sld, SLD):
self.polymer_sld = polymer_sld
else:
self.polymer_sld = SLD(polymer_sld)
# left and right slabs are other areas where the same polymer can
# reside
self.left_slabs = [slab for slab in left_slabs if
isinstance(slab, Slab)]
self.right_slabs = [slab for slab in right_slabs if
isinstance(slab, Slab)]
self.microslab_max_thickness = microslab_max_thickness
# dz are the spatial spacings of the spline knots
self.dz = Parameters(name='dz - spline')
for i, z in enumerate(dz):
p = possibly_create_parameter(
z,
name='%s - spline dz[%d]' % (name, i))
p.range(0, 1)
self.dz.append(p)
# vf are the volume fraction values of each of the spline knots
self.vf = Parameters(name='vf - spline')
for i, v in enumerate(vf):
p = possibly_create_parameter(
v,
name='%s - spline vf[%d]' % (name, i))
p.range(0, 2.)
self.vf.append(p)
if len(self.vf) != len(self.dz):
raise ValueError("dz and vs must have same number of entries")
self.monotonic_penalty = monotonic_penalty
self.zgrad = zgrad
self.interpolator = interpolator
self.__cached_interpolator = {'zeds': np.array([]),
'vf': np.array([]),
'interp': None}
def __init__(self, value=None, A=None, B=0, C=0, name=""):
if (type(value) is str
and name == ""): # if there is no name get it from the path
name = os.path.basename(value).split(".")[0]
super(RI, self).__init__(name=name)
assert np.logical_xor(
value is None,
A is None), "Supply either values or cauchy parameters"
if value is not None:
if type(value) is str:
try:
self._wav, self._RI, self._EC = np.loadtxt(
value, skiprows=1, delimiter=",", encoding="utf8").T
except ValueError:
self._wav, self._RI = np.loadtxt(
value,
skiprows=1,
delimiter=",",
usecols=[0, 1],
encoding="utf8",
).T
self._EC = np.zeros_like(self._wav)
elif len(value) == 2:
self._RI, self._EC = value
self._wav = None
elif len(value) == 3:
self._wav, self._RI, self._EC = value
else:
raise TypeError("format not recognised")
# convert wavelength from um to nm
self._wav = self._wav * 1000
else:
self._wav = None
self._RI = None
self._EC = None
self.model = None
self.set_wav = None
self._default_wav = 658
self._parameters = Parameters(name=name)
if A is not None:
self.A = possibly_create_parameter(A, name=f"{name} - cauchy A")
self.B = possibly_create_parameter(B, name=f"{name} - cauchy B")
self.C = possibly_create_parameter(C, name=f"{name} - cauchy C")
self._parameters.extend([self.A, self.B, self.C])
def __init__(self,
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
rough_head_tail,
rough_preceding_mono,
water_vm,
waters_per_head,
waters_per_tail,
b_mscl,
vm_mscl,
PLRatio,
head_solvent=None,
tail_solvent=None,
reverse_monolayer=False,
name=''):
super(LipidLeafletWithProtien,
self).__init__(apm, b_heads, vm_heads, thickness_heads, b_tails,
vm_tails, thickness_tails, rough_head_tail,
rough_preceding_mono, head_solvent, tail_solvent,
reverse_monolayer, name)
if isinstance(b_mscl, complex):
self.b_mscl_real = possibly_create_parameter(
b_mscl.real, name='%s - b_mscl_real' % name)
self.b_mscl_imag = possibly_create_parameter(
b_mscl.imag, name='%s - b_mscl_imag' % name)
elif isinstance(b_mscl, SLD):
self.b_mscl_real = b_mscl.real
self.b_mscl_imag = b_mscl.imag
else:
self.b_mscl_real = possibly_create_parameter(
b_mscl, name='%s - b_mscl_real' % name)
self.b_mscl_imag = possibly_create_parameter(
0, name='%s - b_mscl_imag' % name)
self.vm_mscl = possibly_create_parameter(
vm_mscl, name='%s - vm_mscl, protien volume' % name)
self.PLRatio = possibly_create_parameter(
PLRatio, name='%s - PLRatio, protien lipid ratio' % name)
self.water_vm = possibly_create_parameter(water_vm,
name='%s - water_vm' % name)
self.waters_per_head = possibly_create_parameter(
waters_per_head, name='%s - waters_per_head' % name)
self.waters_per_tail = possibly_create_parameter(
waters_per_tail, name='%s - waters_per_tail' % name)
def __init__(self,
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
rough_head_tail,
rough_preceding_mono,
water_vm,
waters_per_head,
waters_per_tail,
vm_mscl,
PLRatio,
head_solvent=None,
tail_solvent=None,
reverse_monolayer=False,
name=''):
super(LipidLeafletWithProtien,
self).__init__(apm, b_heads, vm_heads, thickness_heads, b_tails,
vm_tails, thickness_tails, rough_head_tail,
rough_preceding_mono, water_vm, waters_per_head,
waters_per_tail, head_solvent, tail_solvent,
reverse_monolayer, name)
# if isinstance(b_mscl, complex):
# self.b_mscl_real = possibly_create_parameter(
# b_mscl.real,
# name='%s - b_mscl_real' % name)
# self.b_mscl_imag = possibly_create_parameter(
# b_mscl.imag,
# name='%s - b_mscl_imag' % name)
# elif isinstance(b_mscl, SLD):
# self.b_mscl_real = b_mscl.real
# self.b_mscl_imag = b_mscl.imag
# else:
# self.b_mscl_real = possibly_create_parameter(
# b_mscl,
# name='%s - b_mscl_real' % name)
# self.b_mscl_imag = possibly_create_parameter(
# 0,
# name='%s - b_mscl_imag' % name)
self.vm_mscl = possibly_create_parameter(
vm_mscl, name='%s - vm_mscl, protien volume' % name)
self.PLRatio = possibly_create_parameter(
PLRatio, name='%s - PLRatio, fraction lipid to protein' % name)
def __init__(self,
extent,
vs,
dz,
left,
right,
solvent,
name='',
interpolator=Pchip,
zgrad=True,
microslab_max_thickness=1):
self.name = name
self.left_slab = left
self.right_slab = right
self.solvent = solvent
self.microslab_max_thickness = microslab_max_thickness
self.extent = (possibly_create_parameter(extent,
name='%s - spline extent' %
name))
self.dz = Parameters(name='dz - spline')
for i, z in enumerate(dz):
p = possibly_create_parameter(z,
name='%s - spline dz[%d]' %
(name, i))
p.range(0, 1)
self.dz.append(p)
self.vs = Parameters(name='vs - spline')
for i, v in enumerate(vs):
p = possibly_create_parameter(v,
name='%s - spline vs[%d]' %
(name, i))
self.vs.append(p)
if len(self.vs) != len(self.dz):
raise ValueError("dz and vs must have same number of entries")
self.zgrad = zgrad
self.interpolator = interpolator
self.__cached_interpolator = {
'zeds': np.array([]),
'vs': np.array([]),
'interp': None,
'extent': -1
}
def __init__(self, models, scales, add_params=None, bkg=1e-7, name='',
dq=5, threads=-1, quad_order=17):
super().__init__(bkg=1e-7, name='', dq=5, threads=-1, quad_order=17)
self.models = models
if scales is not None and len(models) == len(scales):
tscales = scales
elif scales is not None and len(models) != len(scales):
raise ValueError("You need to supply scale factor for each"
" structure")
else:
tscales = [1 / len(models)] * len(models)
pscales = []
for scale_num, scale in enumerate(tscales):
p_scale = possibly_create_parameter(scale, name='scale %d'%scale_num)
pscales.append(p_scale)
self._scales = pscales
if add_params is not None:
self.additional_params = []
for param in add_params:
self.additional_params.append(param)
def __init__(
self,
model,
data,
lnsigma=None,
use_weights=True,
transform=None,
logp_extra=None,
name=None,
):
self.model = model
# should be a DataSE instance
if type(data) is DataSE:
self.data = data
else:
print("bad")
self.data = DataSE(data=data)
self.lnsigma = lnsigma
if lnsigma is not None:
self.lnsigma = possibly_create_parameter(lnsigma, "lnsigma")
self._use_weights = use_weights
self.transform = transform
self.logp_extra = logp_extra
self.name = name
if name is None:
self.name = id(self)
self.model._flip_delta = self.data._delta_flipped
def __init__(
self,
model,
data,
lnsigma=None,
use_weights=True,
transform=None,
logp_extra=None,
name=None,
):
self.model = model
# should be a Data1D instance
if isinstance(data, Data1D):
self.data = data
else:
self.data = Data1D(data=data)
self.lnsigma = lnsigma
if lnsigma is not None:
self.lnsigma = possibly_create_parameter(lnsigma, "lnsigma")
self._use_weights = use_weights
self.transform = transform
self.logp_extra = logp_extra
self.name = name
if name is None:
self.name = id(self)
def remove_structure(self, row):
# don't remove the last structure
if row < STRUCT_OFFSET or len(self.structures) < 2:
return
# you have to be a mixedreflectmodel because there's more than one
# structure
data_object_node = find_data_object(self.index)
data_object = data_object_node.data_object
orig_model = data_object.model
structures = orig_model.structures
scales = orig_model.scales
# going down to a single reflectmodel
if len(structures) == 2:
self._model.beginRemoveRows(self.index, row, row)
# remove all dependent parameters (either in this dataset or
# elsewhere)
# do this before the Structure is popped.
self._model.unlink_dependent_parameters(self.child(row))
structures.pop(row - STRUCT_OFFSET)
scales.pop(row - STRUCT_OFFSET)
sf = possibly_create_parameter(scales[0], name="scale")
new_model = ReflectModel(structures[0],
scale=sf,
bkg=orig_model.bkg,
dq=orig_model.dq)
data_object.model = new_model
self.popChild(row)
self._model.endRemoveRows()
n = ParNode(sf, self._model, self)
self._model.beginInsertRows(self.index, 0, 0)
self.insertChild(0, n)
self._model.endInsertRows()
self._model.beginRemoveRows(self.index, 1, 1)
self.popChild(1)
self._model.endRemoveRows()
# data_object_node.set_reflect_model(new_model)
return
# you're not down to a single structure, so there must have been more
# than 2 structures
self._model.beginRemoveRows(self.index, row, row)
# remove all dependent parameters (either in this dataset or elsewhere)
# do this before the Structure is popped.
self._model.unlink_dependent_parameters(self.child(row))
# pop the structure and scale factor nodes
self.popChild(row)
structures.pop(row - STRUCT_OFFSET)
scales.pop(row - STRUCT_OFFSET)
self._model.endRemoveRows()
self._model.beginRemoveRows(
self.child(0).index, row - STRUCT_OFFSET, row - STRUCT_OFFSET)
self.child(0).popChild(row - STRUCT_OFFSET)
self._model.endRemoveRows()
def __init__(
self,
structures,
scales=None,
bkg=1e-7,
name="",
dq=5.0,
threads=-1,
quad_order=17,
dq_type="pointwise",
q_offset=0.0,
):
self.name = name
self._parameters = None
self.threads = threads
self.quad_order = quad_order
# all reflectometry models need a scale factor and background. Set
# them all to 1 by default.
pscales = Parameters(name="scale factors")
if scales is not None and len(structures) == len(scales):
tscales = scales
elif scales is not None and len(structures) != len(scales):
raise ValueError("You need to supply scale factor for each"
" structure")
else:
tscales = [1 / len(structures)] * len(structures)
for scale in tscales:
p_scale = possibly_create_parameter(scale, name="scale")
pscales.append(p_scale)
self._scales = pscales
self._bkg = possibly_create_parameter(bkg, name="bkg")
# we can optimize the resolution (but this is always overridden by
# x_err if supplied. There is therefore possibly no dependence on it.
self._dq = possibly_create_parameter(dq, name="dq - resolution")
self.dq_type = dq_type
self._q_offset = possibly_create_parameter(q_offset,
name="q_offset",
units="Å**-1")
self._structures = structures
def __init__(
self,
extent,
vs,
dz,
name="",
interpolator=Pchip,
zgrad=True,
microslab_max_thickness=1,
):
super(Spline, self).__init__()
self.name = name
self.microslab_max_thickness = microslab_max_thickness
self.extent = possibly_create_parameter(extent,
name="%s - spline extent" %
name)
self.dz = Parameters(name="dz - spline")
for i, z in enumerate(dz):
p = possibly_create_parameter(z,
name="%s - spline dz[%d]" %
(name, i))
p.range(0, 1)
self.dz.append(p)
self.vs = Parameters(name="vs - spline")
for i, v in enumerate(vs):
p = possibly_create_parameter(v,
name="%s - spline vs[%d]" %
(name, i))
self.vs.append(p)
if len(self.vs) != len(self.dz):
raise ValueError("dz and vs must have same number of entries")
self.zgrad = zgrad
self.interpolator = interpolator
self.__cached_interpolator = {
"zeds": np.array([]),
"vs": np.array([]),
"interp": None,
"extent": -1,
}
def __init__(self, extent, decay, rough, left_component, right_component,
name='', reverse=False, microslab_max_thickness=1):
super(FunctionalForm, self).__init__(name=name)
self.left_component = left_component
self.right_component = right_component
self.reverse = reverse
self.microslab_max_thickness = microslab_max_thickness
self.extent = (
possibly_create_parameter(extent,
name='%s - functional extent' % name))
self.decay = (
possibly_create_parameter(decay, name='%s - decay length' % name))
self.rough = (
possibly_create_parameter(rough, name='%s - rough' % name))
def __init__(self,
thick,
rough,
vol_protein,
PLratio,
solventSLD,
name='',
vfsolv=0,
interface=None,
sld=None):
if sld == None:
sld = 0
super(Protrusion, self).__init__(thick, sld, rough, name, vfsolv,
interface)
self.vol_protein = possibly_create_parameter(
vol_protein, name='%s - vm_mscl, protien volume' % name)
self.PLratio = possibly_create_parameter(
PLratio, name='%s - PLratio, protien lipid ratio' % name)
if isinstance(solventSLD, SLD):
self.solventSLD = solventSLD
elif isinstance(solventSLD, complex):
self.solventSLD = SLD(solventSLD)
else:
self.solventSLD = possibly_create_parameter(
solventSLD, name='%s - solventSLD' % name)
bo = 0.5804e-4 #Oxygen
bh = -0.3741e-4 #Hydrogen
bd = 0.6671e-4 #Deuterium
D2O = (2 * bd) + (1 * bo)
H2O = (2 * bh) + (1 * bo)
self.D2O = float(D2O)
self.H2O = float(H2O)
bc = 0.6646e-4 #Carbon
# bo = 0.5804e-4 #Oxygen
# bh = -0.3739e-4 #Hydrogen
#bp = 0.513e-4 #Phosphorus
bn = 0.936e-4 #Nitrogen
bs = 2.847e-4 #Sulphur
self.b_protein_part = float(2745 * bc + 675 * bn + 641 * bo + 25 * bs +
(4374.5 - 822.5 * 0.9) * bh)
def __init__(self, thick, sld, rough, name='', vfsolv=0, interface=None):
super(Slab, self).__init__(name=name)
self.thick = possibly_create_parameter(thick, name='%s - thick' % name)
if isinstance(sld, SLD):
self.sld = sld
else:
self.sld = SLD(sld)
self.rough = possibly_create_parameter(rough, name='%s - rough' % name)
self.vfsolv = (possibly_create_parameter(vfsolv,
name='%s - volfrac solvent' %
name))
p = Parameters(name=self.name)
p.extend([
self.thick, self.sld.real, self.sld.imag, self.rough, self.vfsolv
])
self._parameters = p
self.interfaces = interface
def __init__(self,
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
rough_head_tail,
rough_preceding_mono,
water_vm,
waters_per_head,
waters_per_tail,
head_solvent=None,
tail_solvent=None,
reverse_monolayer=False,
name=''):
super(LipidLeafletWithWaterPer,
self).__init__(apm, b_heads, vm_heads, thickness_heads, b_tails,
vm_tails, thickness_tails, rough_head_tail,
rough_preceding_mono, head_solvent, tail_solvent,
reverse_monolayer, name)
self.water_vm = possibly_create_parameter(water_vm,
name='%s - water_vm' % name)
self.waters_per_head = possibly_create_parameter(
waters_per_head, name='%s - waters_per_head' % name)
self.waters_per_tail = possibly_create_parameter(
waters_per_tail, name='%s - waters_per_tail' % name)
bo = 0.5804e-4 #Oxygen
bh = -0.3741e-4 #Hydrogen
bd = 0.6671e-4 #Deuterium
D2O = (2 * bd) + (1 * bo)
H2O = (2 * bh) + (1 * bo)
self.D2O = float(D2O)
self.H2O = float(H2O)
def __init__ (self, structure, loc_in_struct, param_name='Thickness',
pdf=None, pdf_kwargs=None, num_structs=11, scale=1, bkg=1e-7,
name='', dq=5, threads=-1, quad_order=17):
self.name = name
self._parameters = None
self.threads = threads
self.quad_order = quad_order
self.master_structure = structure
self.loc_in_struct = loc_in_struct
self.param_name = param_name.lower()
self.num_structs = num_structs
self._scale = scale
if pdf is None:
self.pdf = norm.pdf
if pdf_kwargs is None:
self.pdf_params = []
self.pdf_params.append(possibly_create_parameter(value=10, name='loc'))
self.pdf_params.append(possibly_create_parameter(value=1, name='scale'))
else:
print ('Warning: You have provided pdf_kwargs without providing a pdf')
else:
assert pdf_kwargs is not None, 'You must supply pdf_kwargs'
self.pdf = pdf
self.pdf_params = []
for kw in pdf_kwargs:
self.pdf_params.append(possibly_create_parameter(pdf_kwargs[kw], name=kw))
self._structures = self.create_structures()
self._scales = np.ones(self.num_structs)/self.num_structs
self._bkg = possibly_create_parameter(bkg, name='bkg')
# we can optimize the resolution (but this is always overridden by
# x_err if supplied. There is therefore possibly no dependence on it.
self._dq = possibly_create_parameter(dq, name='dq - resolution')
self.generate_thicknesses()
def __init__(self, name, bs, thicks, roughs, totalThickness):
super(NLayerModel, self).__init__()
self.Nlayers = len(bs)
self.bs = []
self.thicks = []
self.roughs = []
self.name = name
for i in range(self.Nlayers):
self.bs.append(
possibly_create_parameter(bs[i],
name='%s - layer %d b_real' %
(name, i)))
self.thicks.append(
possibly_create_parameter(thicks[i],
name='%s - thickness %d thickness' %
(name, i)))
self.roughs.append(
possibly_create_parameter(roughs[i],
name='%s - layer %d roughness' %
(name, i)))
self.totalThickness = possibly_create_parameter(
totalThickness, name='%s - total thickness' % (name))
def __init__(self,
polymer_sld,
phi_0,
gamma,
alpha,
delta,
rough,
name='',
microslab_max_thickness=1):
super(ParabolicBrush, self).__init__(name=name)
self.polymer_sld = SLD(polymer_sld)
self.gamma = possibly_create_parameter(gamma, name='%s - gamma' % name)
self.microslab_max_thickness = microslab_max_thickness
self.alpha = (possibly_create_parameter(alpha,
name='%s - alpha' % name))
self.delta = (possibly_create_parameter(delta,
name='%s - delta' % name))
self.phi_0 = (possibly_create_parameter(phi_0,
name='%s - phi_0' % name))
self.rough = (possibly_create_parameter(rough,
name='%s - rough' % name))
def __init__(self,
structure,
scale=1,
bkg=1e-7,
name='',
dq=5.,
threads=0,
quad_order=17):
self.name = name
self._parameters = None
self.threads = threads
self.quad_order = quad_order
# all reflectometry models need a scale factor and background
self._scale = possibly_create_parameter(scale, name='scale')
self._bkg = possibly_create_parameter(bkg, name='bkg')
# we can optimize the resolution (but this is always overridden by
# x_err if supplied. There is therefore possibly no dependence on it.
self._dq = possibly_create_parameter(dq, name='dq - resolution')
self._structure = None
self.structure = structure
def __init__(self,
structures,
scales=None,
bkg=1e-7,
name='',
dq=5.,
threads=-1,
quad_order=17):
self.name = name
self._parameters = None
self.threads = threads
self.quad_order = quad_order
# all reflectometry models need a scale factor and background. Set
# them all to 1 by default.
pscales = Parameters('scale factors')
if scales is not None and len(structures) == len(scales):
tscales = scales
elif scales is not None and len(structures) != len(scales):
raise ValueError("You need to supply scale factor for each"
" structure")
else:
tscales = [1 / len(structures)] * len(structures)
for scale in tscales:
p_scale = possibly_create_parameter(scale, name='scale')
pscales.append(p_scale)
self._scales = pscales
self._bkg = possibly_create_parameter(bkg, name='bkg')
# we can optimize the resolution (but this is always overridden by
# x_err if supplied. There is therefore possibly no dependence on it.
self._dq = possibly_create_parameter(dq, name='dq - resolution')
self._structures = structures
def __init__(self, components=(), name='', repeats=1):
Component.__init__(self, name=name)
UserList.__init__(self) # explicit calls without super
self.repeats = possibly_create_parameter(repeats, 'repeats')
self.repeats.bounds.lb = 1
# if you provide a list of components to start with, then initialise
# the Stack from that
for c in components:
if isinstance(c, Component):
self.data.append(c)
else:
raise ValueError("You can only initialise a Stack with"
" Components")
def __init__(self,
i_as=11.1,
sig_as=0.1,
i_ap=24.1,
th_p=25.1,
i_ps=24.1,
n_w=500.1,
d_sld=2.01,
a=13,
b=16.5,
c=27.5):
#interface air solvent, interface width air solvent, interface air protien, interface protien solvent, number of water molecules, sld of deuterated protein
super(bsla_thesis).__init__()
name = 'bsla'
self.name = name
self.interface_air_protein = possibly_create_parameter(
0.0, name='%s - interface_air_protein' % name)
self.interface_protein_solvent = possibly_create_parameter(
11.1, name='%s - interface_protein_solvent' % name)
self.protein_length = possibly_create_parameter(
25.1, name='%s - protein_length' % name)
self.number_of_water_molecules = possibly_create_parameter(
500.1, name='%s - number_of_water_molecules' % name)
self.interface_width_air_solvent = possibly_create_parameter(
15, name='%s - interface_width_air_solvent' % name)
#self.interface_width_protein_solvent = possibly_create_parameter(0.1,
# name='%s - interface_width_protein_solvent' % name)
self.sld_of_protein = possibly_create_parameter(
3.23, #*(10**(-6))
name='%s - sld_of_protein' % name)
self.d2o_to_h2o_ratio = possibly_create_parameter(
1.0, name='%s - d2o_h2o_ratio' % name)
# self.semi_axis_a = possibly_create_parameter(a,
# name='%s - semi_axis_a' % name)
# self.semi_axis_b = possibly_create_parameter(b,
# name='%s - semi_axis_b' % name)
# self.semi_axis_c = possibly_create_parameter(c,
# name='%s - semi_axis_c' % name)
self.a = 13
self.b = 16.5
self.c = 27.5
self.volume_of_water_molecule = 30
self.major_axis_length = 55
self.d = (self.c - self.a) / self.volume_of_water_molecule
def insert_structure(self, row, structure):
n = StructureNode(structure, self._model, self)
data_object_node = find_data_object(self.index)
data_object = data_object_node.data_object
orig_model = data_object.model
if len(self.structures) == 1:
self._model.beginInsertRows(self.index, row, row)
new_structures = [self.structures[0], structure]
new_model = MixedReflectModel(new_structures,
bkg=orig_model.bkg,
dq=orig_model.dq)
data_object.model = new_model
data_object_node.set_reflect_model(new_model,
constdq_q=self.constantdq_q)
return
# already a mixed model
# we can't insert at a lower place than the 4rd row
row = max(row, 4)
self._model.beginInsertRows(self.index, row, row)
# insert the structure
orig_model.structures.insert(row - STRUCT_OFFSET, structure)
v = 1 / len(orig_model.structures)
sf = possibly_create_parameter(v, name="scale")
orig_model.scales.insert(row - STRUCT_OFFSET, sf)
self.insertChild(row, n)
self._model.endInsertRows()
# insert a scale factor
self._model.beginInsertRows(
self.child(0).index, row - STRUCT_OFFSET, row - STRUCT_OFFSET)
# add a scale factor
n = ParNode(sf, self._model, self.child(0))
self.child(0).insertChild(row - STRUCT_OFFSET, n)
self._model.endInsertRows()
def __init__(
self,
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
rough_head_tail,
rough_preceding_mono,
# water_vm, waters_per_head, waters_per_tail,
vm_mscl,
PLRatio,
head_solvent=None,
tail_solvent=None,
reverse_monolayer=False,
name=''):
self.vm_mscl = possibly_create_parameter(
vm_mscl, name='%s - vm_mscl, protien volume' % name)
self.PLRatio = possibly_create_parameter(
PLRatio, name='%s - PLRatio, fraction lipid to protein' % name)
super(LipidLeafletWithProtien, self).__init__(
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
rough_head_tail,
rough_preceding_mono,
# water_vm, waters_per_head, waters_per_tail,
head_solvent,
tail_solvent,
reverse_monolayer,
name)
# if isinstance(b_mscl, complex):
# self.b_mscl_real = possibly_create_parameter(
# b_mscl.real,
# name='%s - b_mscl_real' % name)
# self.b_mscl_imag = possibly_create_parameter(
# b_mscl.imag,
# name='%s - b_mscl_imag' % name)
# elif isinstance(b_mscl, SLD):
# self.b_mscl_real = b_mscl.real
# self.b_mscl_imag = b_mscl.imag
# else:
# self.b_mscl_real = possibly_create_parameter(
# b_mscl,
# name='%s - b_mscl_real' % name)
# self.b_mscl_imag = possibly_create_parameter(
# 0,
# name='%s - b_mscl_imag' % name)
bc = 0.6646e-4 #Carbon
bo = 0.5804e-4 #Oxygen
bh = -0.3739e-4 #Hydrogen
#bp = 0.513e-4 #Phosphorus
bn = 0.936e-4 #Nitrogen
#bd = 0.6671e-4 #Deuterium
bs = 2.847e-4 #Sulphur
self.b_mscl_base = float(2745 * bc + 675 * bn + 641 * bo + 25 * bs +
(4374.5 - 822.5 * 0.9) * bh)
# bo = 0.5804e-4 #Oxygen
# bh = -0.3741e-4 #Hydrogen
bd = 0.6671e-4 #Deuterium
D2O = (2 * bd) + (1 * bo)
H2O = (2 * bh) + (1 * bo)
self.D2O = float(D2O)
self.H2O = float(H2O)
def __init__(self, apm, b_heads, vm_heads, thickness_heads,
b_tails, vm_tails, thickness_tails, rough_head_tail,
rough_preceding_mono, reverse_monolayer=False, name=''):
"""
Parameters
----------
apm: float or Parameter
Area per molecule
b_heads: float, Parameter or complex
Sum of coherent scattering lengths of head group (Angstrom)
vm_heads: float or Parameter
Molecular volume of head group (Angstrom**3)
thickness_heads: float or Parameter
Thickness of head group region (Angstrom)
b_tails: float, Parameter or complex
Sum of coherent scattering lengths of tail group (Angstrom)
vm_tails: float or Parameter
Molecular volume of tail group (Angstrom**3)
thickness_tails: float or Parameter
Thickness of head group region (Angstrom)
reverse_monolayer: bool, optional
The default is to have heads closer to the fronting medium and
tails closer to the backing medium. If `reverse_monolayer is True`
then the tails will be closer to the fronting medium and heads
closer to the backing medium.
name: str, optional
The name for the component
"""
super(LipidLeaflet, self).__init__()
self.apm = possibly_create_parameter(apm,
'%s - area_per_molecule' % name)
if isinstance(b_heads, complex):
self.b_heads_real = possibly_create_parameter(
b_heads.real,
name='%s - b_heads_real' % name)
self.b_heads_imag = possibly_create_parameter(
b_heads.imag,
name='%s - b_heads_imag' % name)
else:
self.b_heads_real = possibly_create_parameter(
b_heads,
name='%s - b_heads_real' % name)
self.b_heads_imag = possibly_create_parameter(
0,
name='%s - b_heads_imag' % name)
self.vm_heads = possibly_create_parameter(
vm_heads,
name='%s - vm_heads' % name)
self.thickness_heads = possibly_create_parameter(
thickness_heads,
name='%s - thickness_heads' % name)
if isinstance(b_tails, complex):
self.b_tails_real = possibly_create_parameter(
b_tails.real,
name='%s - b_tails_real' % name)
self.b_tails_imag = possibly_create_parameter(
b_tails.imag,
name='%s - b_tails_imag' % name)
else:
self.b_tails_real = possibly_create_parameter(
b_tails,
name='%s - b_tails_real' % name)
self.b_tails_imag = possibly_create_parameter(
0,
name='%s - b_tails_imag' % name)
self.vm_tails = possibly_create_parameter(
vm_tails,
name='%s - vm_tails' % name)
self.thickness_tails = possibly_create_parameter(
thickness_tails,
name='%s - thickness_tails' % name)
self.rough_head_tail = possibly_create_parameter(
rough_head_tail,
name='%s - rough_head_tail' % name)
self.rough_preceding_mono = possibly_create_parameter(
rough_preceding_mono,
name='%s - rough_fronting_mono' % name)
self.reverse_monolayer = reverse_monolayer
self.name = name
def __init__(self,
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
roughness,
solvfrac=0,
head_solvent=None,
reverse_monolayer=False,
name=''):
super(monolayer, self).__init__()
self.apm = possibly_create_parameter(apm, 'area_per_molecule')
if isinstance(b_heads, complex):
self.b_heads_real = possibly_create_parameter(b_heads.real,
name='b_heads_real')
self.b_heads_imag = possibly_create_parameter(b_heads.imag,
name='b_heads_imag')
elif isinstance(b_heads, SLD):
self.b_heads_real = b_heads.real
self.b_heads_imag = b_heads.imag
else:
self.b_heads_real = possibly_create_parameter(b_heads,
name='b_heads_real')
self.b_heads_imag = possibly_create_parameter(0,
name='b_heads_imag')
self.vm_heads = possibly_create_parameter(vm_heads, name='vm_heads')
self.thickness_heads = possibly_create_parameter(
thickness_heads, name='thickness_heads')
if isinstance(b_tails, complex):
self.b_tails_real = possibly_create_parameter(b_tails.real,
name='b_tails_real')
self.b_tails_imag = possibly_create_parameter(b_tails.imag,
name='b_tails_imag')
elif isinstance(b_tails, SLD):
self.b_tails_real = b_tails.real
self.b_tails_imag = b_tails.imag
else:
self.b_tails_real = possibly_create_parameter(b_tails,
name='b_tails_real')
self.b_tails_imag = possibly_create_parameter(0,
name='b_tails_imag')
self.vm_tails = possibly_create_parameter(vm_tails, name='vm_tails')
self.thickness_tails = possibly_create_parameter(
thickness_tails, name='thickness_tails')
self.roughness = possibly_create_parameter(roughness, name='roughness')
self.head_solvent = None
if head_solvent == 'd2o':
self.head_solvent = 6.02316
else:
self.head_solvent = 2.3117
self.solvfrac = possibly_create_parameter(solvfrac, 'solvent fraction')
self.reverse_monolayer = reverse_monolayer
self.name = name
def __init__(self,
apm,
b_heads,
vm_heads,
thickness_heads,
b_tails,
vm_tails,
thickness_tails,
rough_head_tail,
rough_preceding_mono,
head_solvent=None,
tail_solvent=None,
reverse_monolayer=False,
name=''):
"""
Parameters
----------
apm: float or Parameter
Area per molecule
b_heads: float, Parameter or complex
Sum of coherent scattering lengths of head group (Angstrom)
vm_heads: float or Parameter
Molecular volume of head group (Angstrom**3)
thickness_heads: float or Parameter
Thickness of head group region (Angstrom)
b_tails: float, Parameter or complex
Sum of coherent scattering lengths of tail group (Angstrom)
vm_tails: float or Parameter
Molecular volume of tail group (Angstrom**3)
thickness_tails: float or Parameter
Thickness of head group region (Angstrom)
rough_preceding_mono: float or Parameter
Roughness between preceding component (in the fronting direction)
and the monolayer (Angstrom). If `reverse_monolayer is False` then
this is the roughness between the preceding component and the
heads, if `reverse_monolayer is True` then this is the roughness
between the preceding component and the tails.
head_solvent: None, float, complex, SLD
Solvent for the head region. If `None`, then solvation will be
performed by the parent `Structure`, using the `Structure.solvent`
attribute. Other options are coerced to an `SLD` object using
`SLD(float | complex)`. A float/complex argument is the SLD of the
solvent (10**-6 Angstrom**-2).
tail_solvent: None, float, complex, SLD
Solvent for the tail region. If `None`, then solvation will be
performed by the parent `Structure`, using the `Structure.solvent`
attribute. Other options are coerced to an `SLD` object using
`SLD(float | complex)`. A float/complex argument is the SLD of the
solvent (10**-6 Angstrom**-2).
reverse_monolayer: bool, optional
The default is to have heads closer to the fronting medium and
tails closer to the backing medium. If `reverse_monolayer is True`
then the tails will be closer to the fronting medium and heads
closer to the backing medium.
name: str, optional
The name for the component
"""
super(LipidLeaflet, self).__init__()
self.apm = possibly_create_parameter(apm,
'%s - area_per_molecule' % name)
if isinstance(b_heads, complex):
self.b_heads_real = possibly_create_parameter(
b_heads.real, name='%s - b_heads_real' % name)
self.b_heads_imag = possibly_create_parameter(
b_heads.imag, name='%s - b_heads_imag' % name)
else:
self.b_heads_real = possibly_create_parameter(
b_heads, name='%s - b_heads_real' % name)
self.b_heads_imag = possibly_create_parameter(
0, name='%s - b_heads_imag' % name)
self.vm_heads = possibly_create_parameter(vm_heads,
name='%s - vm_heads' % name)
self.thickness_heads = possibly_create_parameter(
thickness_heads, name='%s - thickness_heads' % name)
if isinstance(b_tails, complex):
self.b_tails_real = possibly_create_parameter(
b_tails.real, name='%s - b_tails_real' % name)
self.b_tails_imag = possibly_create_parameter(
b_tails.imag, name='%s - b_tails_imag' % name)
else:
self.b_tails_real = possibly_create_parameter(
b_tails, name='%s - b_tails_real' % name)
self.b_tails_imag = possibly_create_parameter(
0, name='%s - b_tails_imag' % name)
self.vm_tails = possibly_create_parameter(vm_tails,
name='%s - vm_tails' % name)
self.thickness_tails = possibly_create_parameter(
thickness_tails, name='%s - thickness_tails' % name)
self.rough_head_tail = possibly_create_parameter(
rough_head_tail, name='%s - rough_head_tail' % name)
self.rough_preceding_mono = possibly_create_parameter(
rough_preceding_mono, name='%s - rough_fronting_mono' % name)
self.head_solvent = self.tail_solvent = None
if head_solvent is not None:
self.head_solvent = SLD(head_solvent)
if tail_solvent is not None:
self.tail_solvent = SLD(tail_solvent)
self.reverse_monolayer = reverse_monolayer
self.name = name
def __init__(self, bs, name="two_layer"):
super(TwoLayer, self).__init__()
if isinstance(bs[0], complex):
self.b_real_h = possibly_create_parameter(
bs[0].real, "{} - b_real_head".format(name))
self.b_imag_h = possibly_create_parameter(
bs[0].imag, "{} - b_imag_head".format(name))
else:
self.b_real_h = possibly_create_parameter(
bs[0], "{} - b_real_head".format(name))
self.b_imag_h = possibly_create_parameter(
0, "{} - b_imag_head".format(name))
if isinstance(bs[1], complex):
self.b_real_t = possibly_create_parameter(
bs[1].real, "{} - b_real_tail".format(name))
self.b_imag_t = possibly_create_parameter(
bs[1].imag, "{} - b_imag_tail".format(name))
else:
self.b_real_t = possibly_create_parameter(
bs[1], "{} - b_real_tail".format(name))
self.b_imag_t = possibly_create_parameter(
0, "{} - b_imag_tail".format(name))
self.mol_vol_h = possibly_create_parameter(
100, "{} - molecular_volume_head".format(name))
self.mol_vol_t = possibly_create_parameter(
100, "{} - molecular_volume_tail".format(name))
self.thick_h = possibly_create_parameter(
100, "{} - thickness_head".format(name))
self.thick_t = possibly_create_parameter(
100, "{} - thickness_tail".format(name))
self.phi_h = possibly_create_parameter(
0.5, "{} - solvation_head".format(name))
self.phi_t = possibly_create_parameter(
0, "{} - solvation_tail".format(name))
self.rough_h_t = possibly_create_parameter(
3.3, "{} - roughness_head_tail".format(name))
self.rough_t_a = possibly_create_parameter(
3.3, "{} - roughness_tail_air".format(name))
self.name = name
def __init__(self, adsorbed_amount, vff, dzf, polymer_sld, name='',
left_slabs=(), right_slabs=(),
interpolator=Pchip, zgrad=True,
microslab_max_thickness=1, profile_cutoff=5000):
"""
Parameters
----------
Adsorbed Amount : Parameter or float
The total extent of the spline region
vff: sequence of Parameter or float
Volume fraction at each of the spline knots, as a fraction of
the volume fraction of the rightmost left slab
dzf : sequence of Parameter or float
Separation of successive knots, will be normalised to a 0-1 scale.
polymer_sld : SLD or float
SLD of polymer
name : str
Name of component
gamma : Parameter
The dry adsorbed amount of polymer
left_slabs : sequence of Slab
Polymer Slabs to the left of the spline
right_slabs : sequence of Slab
Polymer Slabs to the right of the spline
interpolator : scipy interpolator
The interpolator for the spline
zgrad : bool, optional
Set to `True` to force the gradient of the volume fraction to zero
at each end of the spline.
microslab_max_thickness : float
Thickness of microslicing of spline for reflectivity calculation.
profile_cutoff : float
maximum extent (thickness) of the freeform profile. The profile is
'cut off' (VF=0) after this point.
"""
super(FreeformVFP, self).__init__()
assert len(vff) + 1 == len(dzf), ("Length of dzf must be one greater"
" than length of vff")
self.name = name
if isinstance(polymer_sld, SLD):
self.polymer_sld = polymer_sld
else:
self.polymer_sld = SLD(polymer_sld)
# left and right slabs are other areas where the same polymer can
# reside
self.left_slabs = [slab for slab in left_slabs if
isinstance(slab, Slab)]
self.right_slabs = [slab for slab in right_slabs if
isinstance(slab, Slab)]
# use the volume fraction of the last left_slab as the initial vf of
# the spline, if not left slabs supplied start at vf 1
if len(self.left_slabs):
self.start_vf = 1 - self.left_slabs[-1].vfsolv.value
else:
self.start_vf = 1
# in contrast use a vf = 0 for the last vf of
# the spline, unless right_slabs is specified
if len(self.right_slabs):
self.end_vf = 1 - self.right_slabs[0].vfsolv.value
else:
self.end_vf = 0
self.microslab_max_thickness = microslab_max_thickness
self.adsorbed_amount = (
possibly_create_parameter(adsorbed_amount,
name='%s - adsorbed amount' % name))
# dzf are the spatial gaps between the spline knots
self.dzf = Parameters(name='dzf - spline')
for i, z in enumerate(dzf):
p = possibly_create_parameter(
z,
name='%s - spline dzf[%d]' % (name, i))
p.range(0, 1)
self.dzf.append(p)
# vf are the volume fraction values of each of the spline knots
self.vff = Parameters(name='vff - spline')
for i, v in enumerate(vff):
p = possibly_create_parameter(
v,
name='%s - spline vff[%d]' % (name, i))
p.range(0, 1)
self.vff.append(p)
self.cutoff = profile_cutoff
self.zgrad = zgrad
self.interpolator = interpolator
self.__cached_interpolator = {'zeds': np.array([]),
'vf': np.array([]),
'interp': None,
'adsorbed amount': -1}
