def __init__(self):
self.data_obs1 = flex.double(2,1.0)
self.data_obs2 = flex.double(2,3.0)
self.sigma_obs1 = flex.double(2,0.1)
self.sigma_obs2 = flex.double(2,1)
self.unit_cell = uctbx.unit_cell('20, 30, 40, 90.0, 90.0, 90.0')
#mi = flex.miller_index(((1,2,3), (1,2,3)))
self.mi = flex.miller_index(((1,2,3), (5,6,7)))
self.xs = crystal.symmetry((20,30,40), "P 2 2 2")
self.ms = miller.set(self.xs, self.mi)
self.u = [1,2,3,4,5,6]
self.p_scale = 0.40
#self.u = [0,0,0,0,0,0]
#self.p_scale = 0.00
self.ls_i_wt = scaling.least_squares_on_i_wt(
self.mi,
self.data_obs1,
self.sigma_obs1,
self.data_obs2,
self.sigma_obs2,
self.p_scale,
self.unit_cell,
self.u)
self.ls_i = scaling.least_squares_on_i(
self.mi,
self.data_obs1,
self.sigma_obs1,
self.data_obs2,
self.sigma_obs2,
self.p_scale,
self.unit_cell,
self.u)
self.ls_f_wt = scaling.least_squares_on_f_wt(
self.mi,
self.data_obs1,
self.sigma_obs1,
self.data_obs2,
self.sigma_obs2,
self.p_scale,
self.unit_cell,
self.u)
self.ls_f = scaling.least_squares_on_f(
self.mi,
self.data_obs1,
self.sigma_obs1,
self.data_obs2,
self.sigma_obs2,
self.p_scale,
self.unit_cell,
self.u)
self.tst_ls_f_wt()
self.tst_ls_i_wt()
self.tst_ls_f()
self.tst_ls_i()
self.tst_hes_ls_i_wt()
self.tst_hes_ls_f_wt()
self.tst_hes_ls_i()
self.tst_hes_ls_f()
def __init__(self):
self.data_obs1 = flex.double(2, 1.0)
self.data_obs2 = flex.double(2, 3.0)
self.sigma_obs1 = flex.double(2, 0.1)
self.sigma_obs2 = flex.double(2, 1)
self.unit_cell = uctbx.unit_cell('20, 30, 40, 90.0, 90.0, 90.0')
#mi = flex.miller_index(((1,2,3), (1,2,3)))
self.mi = flex.miller_index(((1, 2, 3), (5, 6, 7)))
self.xs = crystal.symmetry((20, 30, 40), "P 2 2 2")
self.ms = miller.set(self.xs, self.mi)
self.u = [1, 2, 3, 4, 5, 6]
self.p_scale = 0.40
#self.u = [0,0,0,0,0,0]
#self.p_scale = 0.00
self.ls_i_wt = scaling.least_squares_on_i_wt(
self.mi, self.data_obs1, self.sigma_obs1, self.data_obs2,
self.sigma_obs2, self.p_scale, self.unit_cell, self.u)
self.ls_i = scaling.least_squares_on_i(self.mi, self.data_obs1,
self.sigma_obs1, self.data_obs2,
self.sigma_obs2, self.p_scale,
self.unit_cell, self.u)
self.ls_f_wt = scaling.least_squares_on_f_wt(
self.mi, self.data_obs1, self.sigma_obs1, self.data_obs2,
self.sigma_obs2, self.p_scale, self.unit_cell, self.u)
self.ls_f = scaling.least_squares_on_f(self.mi, self.data_obs1,
self.sigma_obs1, self.data_obs2,
self.sigma_obs2, self.p_scale,
self.unit_cell, self.u)
self.tst_ls_f_wt()
self.tst_ls_i_wt()
self.tst_ls_f()
self.tst_ls_i()
self.tst_hes_ls_i_wt()
self.tst_hes_ls_f_wt()
self.tst_hes_ls_i()
self.tst_hes_ls_f()
def __init__(self,
miller_native,
miller_derivative,
use_intensities=True,
scale_weight=False,
use_weights=False,
mask=[1,1],
start_values=None ):
## This mask allows one to refine only scale factor and only B values
self.mask = mask ## multiplier for gradients of [scale factor, u tensor]
## make deep copies just to avoid any possible problems
self.native = miller_native.deep_copy().set_observation_type(
miller_native)
if not self.native.is_real_array():
raise Sorry("A real array is need for ls scaling")
self.derivative = miller_derivative.deep_copy().set_observation_type(
miller_derivative)
if not self.derivative.is_real_array():
raise Sorry("A real array is need for ls scaling")
if use_intensities:
if not self.native.is_xray_intensity_array():
self.native = self.native.f_as_f_sq()
if not self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_as_f_sq()
if not use_intensities:
if self.native.is_xray_intensity_array():
self.native = self.native.f_sq_as_f()
if self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_sq_as_f()
## Get the common sets
self.native, self.derivative = self.native.map_to_asu().common_sets(
self.derivative.map_to_asu() )
## Get the required information
self.hkl = self.native.indices()
self.i_or_f_nat = self.native.data()
self.sig_nat = self.native.sigmas()
if self.sig_nat is None:
self.sig_nat = self.i_or_f_nat*0 + 1
self.i_or_f_der = self.derivative.data()
self.sig_der = self.derivative.sigmas()
if self.sig_der is None:
self.sig_der = self.i_or_f_der*0+1
self.unit_cell = self.native.unit_cell()
# Modifiy the weights if required
if not use_weights:
self.sig_nat = self.sig_nat*0.0 + 1.0
self.sig_der = self.sig_der*0.0
## Set up the minimiser 'cache'
self.minimizer_object = None
if use_intensities:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_i_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_i(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_f_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_f(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
## Symmetry related issues
self.sg = self.native.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params
## Setup number of parameters
assert self.dim_u()<=6
## Optimisation stuff
x0 = flex.double(self.dim_u()+1, 0.0) ## B-values and scale factor!
if start_values is not None:
assert( start_values.size()==self.x.size() )
x0 = start_values
minimized = newton_more_thuente_1994(
function=self, x0=x0, gtol=0.9e-6, eps_1=1.e-6, eps_2=1.e-6,
matrix_symmetric_relative_epsilon=1.e-6)
Vrwgk = math.pow(self.unit_cell.volume(),2.0/3.0)
self.p_scale = minimized.x_star[0]
self.u_star = self.unpack( minimized.x_star )
self.u_star = list( flex.double(self.u_star) / Vrwgk )
self.b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(self.unit_cell,
self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell,
self.u_star)
def __init__(self,
miller_native,
miller_derivative,
use_intensities=True,
scale_weight=False,
use_weights=False,
mask=[1,1],
start_values=None ):
## This mask allows one to refine only scale factor and only B values
self.mask = mask ## multiplier for gradients of [scale factor, u tensor]
## make deep copies just to avoid any possible problems
self.native = miller_native.deep_copy().set_observation_type(
miller_native)
if not self.native.is_real_array():
raise Sorry("A real array is need for ls scaling")
self.derivative = miller_derivative.deep_copy().set_observation_type(
miller_derivative)
if not self.derivative.is_real_array():
raise Sorry("A real array is need for ls scaling")
if use_intensities:
if not self.native.is_xray_intensity_array():
self.native = self.native.f_as_f_sq()
if not self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_as_f_sq()
if not use_intensities:
if self.native.is_xray_intensity_array():
self.native = self.native.f_sq_as_f()
if self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_sq_as_f()
## Get the common sets
self.native, self.derivative = self.native.map_to_asu().common_sets(
self.derivative.map_to_asu() )
## Get the required information
self.hkl = self.native.indices()
self.i_or_f_nat = self.native.data()
self.sig_nat = self.native.sigmas()
if self.sig_nat is None:
self.sig_nat = self.i_or_f_nat*0 + 1
self.i_or_f_der = self.derivative.data()
self.sig_der = self.derivative.sigmas()
if self.sig_der is None:
self.sig_der = self.i_or_f_der*0+1
self.unit_cell = self.native.unit_cell()
# Modifiy the weights if required
if not use_weights:
self.sig_nat = self.sig_nat*0.0 + 1.0
self.sig_der = self.sig_der*0.0
## Set up the minimiser 'cache'
self.minimizer_object = None
if use_intensities:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_i_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_i(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_f_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_f(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
## Symmetry related issues
self.sg = self.native.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params
## Setup number of parameters
assert self.dim_u()<=6
## Optimisation stuff
x0 = flex.double(self.dim_u()+1, 0.0) ## B-values and scale factor!
if start_values is not None:
assert( start_values.size()==self.x.size() )
x0 = start_values
minimized = newton_more_thuente_1994(
function=self, x0=x0, gtol=0.9e-6, eps_1=1.e-6, eps_2=1.e-6,
matrix_symmetric_relative_epsilon=1.e-6)
Vrwgk = math.pow(self.unit_cell.volume(),2.0/3.0)
self.p_scale = minimized.x_star[0]
self.u_star = self.unpack( minimized.x_star )
self.u_star = list( flex.double(self.u_star) / Vrwgk )
self.b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(self.unit_cell,
self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell,
self.u_star)