def calc_full_mag_elems(mag_elems_o, mag_elems_c):
r_o = mag_elems_o[4:13, :]
r_c = mag_elems_c[4:13, :]
b_n_o = mag_elems_o[:3, :]
b_d_o = mag_elems_o[3:4, :]
b_c = mag_elems_c[:4, :]
theta_o = mag_elems_o[13:14, :]
theta_c = mag_elems_c[13:14, :]
theta_fs = theta_o[:, :, na] * theta_c[:, na, :]
r_fs, dder_r_fs = calc_m1_m2(r_o[:, :, na],
r_c[:, na, :],
flag_m1=False,
flag_m2=False)
rb, dder_rb = calc_m_v(r_c[:, na, :],
b_n_o[:, :, na],
flag_m=False,
flag_v=False)
b_d_o = numpy.broadcast_arrays(b_c[0, na, :], b_d_o[:, :, na])[1]
se_rb = numpy.concatenate([rb, b_d_o], axis=0)
b_fs = sum_elem_symm_b(se_rb, b_c[:, na, :])
res = numpy.concatenate([b_fs, r_fs, theta_fs], axis=0)
res_2d = res.reshape((res.shape[0], numpy.prod(res.shape[1:])), order="C")
mag_elems_fs = res_2d # May be it is not enough and unique elements should be given
# mag_elems_fs = numpy.unique(res_2d, axis=1)
return mag_elems_fs
def calc_asymmetric_unit_cell_indexes(n_abc, full_symm_elems):
"""
Calculate indexes of asymmetric unit cell.
Input parameters:
- symmetry elements;
- points number.
Multiplication of points number on corresponding symmetry element should
give integer number.
"""
n_a, n_b, n_c = n_abc[0], n_abc[1], n_abc[2]
point_index = numpy.stack(numpy.meshgrid(numpy.arange(n_a),
numpy.arange(n_b),
numpy.arange(n_c),
indexing="ij"),
axis=0)
point_index = point_index.reshape(point_index.shape[0],
numpy.prod(point_index.shape[1:]))
elem_r = full_symm_elems[4:13]
elem_b = full_symm_elems[:4]
r_ind = calc_m_v(numpy.expand_dims(elem_r, axis=1),
numpy.expand_dims(point_index, axis=2),
flag_m=False,
flag_v=False)[0]
div, mod = numpy.divmod(numpy.expand_dims(n_abc, axis=1),
numpy.expand_dims(elem_b[3], axis=0))
if not (numpy.all(mod == 0)):
raise KeyError("Symmetry elements do not match with number of points")
point_index_s = numpy.mod(
r_ind + numpy.expand_dims(div * elem_b[:3], axis=1),
numpy.expand_dims(numpy.expand_dims(n_abc, axis=1), axis=2))
value_index_s = n_c * n_b * point_index_s[0] + n_c * point_index_s[
1] + point_index_s[2]
value_index_s_sorted = numpy.sort(value_index_s, axis=1)
a, ind_a_u_c, counts_a_u_c = numpy.unique(value_index_s_sorted[:, 0],
return_index=True,
return_counts=True)
point_index_s_a_u_c = point_index[:, ind_a_u_c]
return point_index_s_a_u_c, counts_a_u_c
def calc_sc_fract_sc_b(symm_elems, atom_fract_xyz):
sc_fract = (symm_elems[4:13]).sum(axis=1) / symm_elems.shape[1]
b_s = symm_elems[:3] / (symm_elems.shape[1] *
numpy.expand_dims(symm_elems[3], axis=0))
atom_fract_xyz = numpy.mod(atom_fract_xyz, 1)
r_s_x = calc_m_v(symm_elems[4:13],
atom_fract_xyz,
flag_m=False,
flag_v=False)[0]
n_s = numpy.expand_dims(atom_fract_xyz, axis=1) - r_s_x - b_s
sc_b = (b_s + n_s).sum(axis=1) / n_s.shape[1]
# sc_b = ().sum(axis=1)
# x_new = calc_m_v(symm_elems[4:13], atom_fract_xyz, flag_m=False, flag_v=False)[0]
# n_s, x0 = numpy.divmod(x_new,1)
# n_s = -n_s.sum(axis=1)/n_s.shape[1]
# sc_b = sc_b + n_s
return sc_fract, sc_b
def calc_chi_sq_for_pd_by_dictionary(
dict_pd,
dict_crystals,
dict_in_out: dict = None,
flag_use_precalculated_data: bool = False,
flag_calc_analytical_derivatives: bool = False):
"""Calculate chi_sq for diffrn experiment.
"""
if dict_in_out is None:
flag_dict = False
flag_use_precalculated_data = False
dict_in_out_keys = []
else:
flag_dict = True
dict_in_out_keys = dict_in_out.keys()
dict_pd_keys = dict_pd.keys()
phase_name = [hh["name"].lower() for hh in dict_crystals]
excluded_points = dict_pd["excluded_points"]
ttheta = dict_pd["ttheta"]
offset_ttheta = dict_pd["offset_ttheta"]
ttheta_zs = ttheta - offset_ttheta
flags_offset_ttheta = dict_pd["flags_offset_ttheta"]
if flag_dict:
dict_in_out["ttheta"] = ttheta_zs
dict_in_out["excluded_points"] = excluded_points
wavelength = dict_pd["wavelength"]
flags_wavelength = dict_pd["flags_wavelength"]
radiation = dict_pd["radiation"]
if "beam_polarization" in dict_pd_keys:
beam_polarization = dict_pd["beam_polarization"]
flipper_efficiency = dict_pd["flipper_efficiency"]
magnetic_field = dict_pd["magnetic_field"]
flags_beam_polarization = dict_pd["flags_beam_polarization"]
flags_flipper_efficiency = dict_pd["flags_flipper_efficiency"]
else:
beam_polarization, flipper_efficiency, magnetic_field = 0., 0., 0.
flags_beam_polarization, flags_flipper_efficiency = False, False
sthovl_min = numpy.sin(0.5 * ttheta_zs.min() - numpy.pi / 90.) / wavelength
if sthovl_min <= 0:
sthovl_min = 0.0001
sthovl_max = numpy.sin(0.5 * ttheta_zs.max() + numpy.pi / 90.) / wavelength
if sthovl_max <= sthovl_min:
sthovl_max = sthovl_min + 0.01
if sthovl_max >= 1.:
sthovl_max = 0.99999 / wavelength
background_ttheta = dict_pd["background_ttheta"]
background_intensity = dict_pd["background_intensity"]
flags_background_intensity = dict_pd["flags_background_intensity"]
flag_background_intensity = numpy.any(flags_background_intensity)
if (flag_use_precalculated_data and ("signal_background" in dict_in_out)
and not (flag_background_intensity)):
signal_background = dict_in_out["signal_background"]
else:
signal_background, dder_s_bkgr = calc_background(
ttheta,
background_ttheta,
background_intensity,
flag_background_intensity=(flag_background_intensity
and flag_calc_analytical_derivatives))
dict_in_out["signal_background"] = signal_background
pd_phase_name = dict_pd["phase_name"]
pd_phase_scale = dict_pd["phase_scale"]
pd_phase_resolution_parameters = dict_pd[
"phase_resolution_parameters"] # U_phase, V_phase, W_phase, X_phase, Y_phase
pd_phase_ig = dict_pd["phase_ig"] # IG_phase
flags_pd_phase_scale = dict_pd["flags_phase_scale"]
flags_pd_phase_resolution_parameters = dict_pd[
"flags_phase_resolution_parameters"] # U_phase, V_phase, W_phase, X_phase, Y_phase
flags_pd_phase_ig = dict_pd["flags_phase_ig"] # IG_phase
resolution_parameters = dict_pd["resolution_parameters"] # U, V, W, X, Y
asymmetry_parameters = dict_pd["asymmetry_parameters"] # p1, p2, p3, p4
flags_resolution_parameters = dict_pd["flags_resolution_parameters"]
flags_asymmetry_parameters = dict_pd["flags_asymmetry_parameters"]
flag_asymmetry_parameters = numpy.any(flags_asymmetry_parameters)
if "texture_name" in dict_pd_keys:
flag_texture = True
pd_texture_name = dict_pd["texture_name"]
pd_texture_g1 = dict_pd["texture_g1"]
pd_texture_g2 = dict_pd["texture_g2"]
pd_texture_axis = dict_pd["texture_axis"]
pd_flags_texture_g1 = dict_pd["flags_texture_g1"]
pd_flags_texture_g2 = dict_pd["flags_texture_g2"]
pd_flags_texture_axis = dict_pd["flags_texture_axis"]
else:
flag_texture = False
k = dict_pd["k"]
cthm = dict_pd["cthm"]
lorentz_factor, dder_lf = calc_lorentz_factor(
ttheta_zs, k=k, cthm=cthm, flag_ttheta=flags_offset_ttheta)
dict_in_out["lorentz_factor"] = lorentz_factor
total_signal_plus = numpy.zeros_like(ttheta_zs)
total_signal_minus = numpy.zeros_like(ttheta_zs)
for p_name, p_scale, p_resolution, p_ig, flags_p_scale, flags_p_resolution, flags_p_ig in zip(
pd_phase_name, pd_phase_scale,
pd_phase_resolution_parameters.transpose(), pd_phase_ig,
flags_pd_phase_scale,
flags_pd_phase_resolution_parameters.transpose(),
flags_pd_phase_ig):
p_name = p_name.lower()
flag_phase_texture = False
if flag_texture:
ind_texture = numpy.argwhere(pd_texture_name == p_name)
if ind_texture.shape[0] != 0:
texture_g1 = pd_texture_g1[ind_texture[0]]
texture_g2 = pd_texture_g2[ind_texture[0]]
texture_axis = pd_texture_axis[:, ind_texture[0]]
flag_phase_texture = True
flags_texture_g1 = pd_flags_texture_g1[ind_texture[0]]
flags_texture_g2 = pd_flags_texture_g2[ind_texture[0]]
flags_texture_axis = pd_flags_texture_axis[:, ind_texture[0]]
ind_phase = phase_name.index(p_name)
dict_crystal = dict_crystals[ind_phase]
dict_in_out_keys = dict_in_out.keys()
if f"dict_in_out_{p_name:}" in dict_in_out_keys:
dict_in_out_phase = dict_in_out[f"dict_in_out_{p_name:}"]
else:
dict_in_out_phase = {}
dict_in_out[f"dict_in_out_{p_name:}"] = dict_in_out_phase
dict_in_out_phase_keys = dict_in_out_phase.keys()
dict_crystal_keys = dict_crystal.keys()
if "reduced_symm_elems" in dict_crystal_keys:
reduced_symm_elems = dict_crystal["reduced_symm_elems"]
translation_elems = dict_crystal["translation_elems"]
elif "full_symm_elems" in dict_crystal_keys:
full_symm_elems = dict_crystal["full_symm_elems"]
elif "full_mcif_elems" in dict_crystal_keys:
full_mcif_elems = dict_crystal["full_mcif_elems"]
unit_cell_parameters = dict_crystal["unit_cell_parameters"]
flags_unit_cell_parameters = dict_crystal["flags_unit_cell_parameters"]
flag_unit_cell_parameters = numpy.any(flags_unit_cell_parameters)
if flag_unit_cell_parameters:
sc_uc = dict_crystal["sc_uc"]
v_uc = dict_crystal["v_uc"]
unit_cell_parameters = numpy.dot(sc_uc,
unit_cell_parameters) + v_uc
if (flag_use_precalculated_data
and ("index_hkl" in dict_in_out_phase_keys)
and ("multiplicity_hkl" in dict_in_out_phase_keys)
and not (flag_unit_cell_parameters or flags_offset_ttheta)):
index_hkl = dict_in_out_phase["index_hkl"]
multiplicity_hkl = dict_in_out_phase["multiplicity_hkl"]
else:
if flag_phase_texture:
reduced_symm_elems_p1 = numpy.array(
[[0], [0], [0], [1], [1], [0], [0], [0], [1], [0], [0],
[0], [1]],
dtype=int)
translation_elems_p1 = numpy.array([[0], [0], [0], [1]],
dtype=int)
index_hkl, multiplicity_hkl = calc_index_hkl_multiplicity_in_range(
sthovl_min, sthovl_max, unit_cell_parameters,
reduced_symm_elems_p1, translation_elems_p1, False)
else:
if "reduced_symm_elems" in dict_crystal_keys:
centrosymmetry = dict_crystal["centrosymmetry"]
index_hkl, multiplicity_hkl = calc_index_hkl_multiplicity_in_range(
sthovl_min, sthovl_max, unit_cell_parameters,
reduced_symm_elems, translation_elems, centrosymmetry)
else:
translation_elems_p1 = numpy.array([[0], [0], [0], [1]],
dtype=int)
index_hkl, multiplicity_hkl = calc_index_hkl_multiplicity_in_range(
sthovl_min, sthovl_max, unit_cell_parameters,
full_mcif_elems[:13], translation_elems_p1, False)
if (("index_hkl" in dict_in_out_phase_keys)
and flag_use_precalculated_data):
if index_hkl.shape != dict_in_out_phase["index_hkl"].shape:
flag_use_precalculated_data = False
else:
flag_use_precalculated_data = numpy.all(
numpy.logical_and(dict_in_out_phase["index_hkl"],
index_hkl))
dict_in_out_phase["index_hkl"] = index_hkl
dict_in_out_phase["multiplicity_hkl"] = multiplicity_hkl
flag_sthovl_hkl = flag_unit_cell_parameters
sthovl_hkl, dder_sthovl_hkl = calc_sthovl_by_unit_cell_parameters(
index_hkl,
unit_cell_parameters,
flag_unit_cell_parameters=flag_unit_cell_parameters)
flag_ttheta_hkl = flag_sthovl_hkl or flags_wavelength
ttheta_hkl = 2 * numpy.arcsin(sthovl_hkl * wavelength)
dict_in_out_phase["ttheta_hkl"] = ttheta_hkl
if radiation[0].startswith("neutrons"):
f_nucl, dder_f_nucl = calc_f_nucl_by_dictionary(
dict_crystal,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_f_nucl = len(dder_f_nucl.keys()) > 0
flag_para = False
if "atom_para_index" in dict_crystal_keys:
sft_ccs, dder_sft_ccs = calc_sft_ccs_by_dictionary(
dict_crystal,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_sft_ccs = len(dder_sft_ccs.keys()) > 0
flag_matrix_t = flag_unit_cell_parameters
matrix_t, dder_matrix_t = calc_matrix_t(
index_hkl,
unit_cell_parameters,
flag_unit_cell_parameters=flag_unit_cell_parameters)
flag_tensor_sigma = flag_sft_ccs or flag_unit_cell_parameters
tensor_sigma, dder_tensor_sigma = calc_m1_m2_m1t(
matrix_t,
sft_ccs,
flag_m1=flag_sft_ccs,
flag_m2=flag_unit_cell_parameters)
flag_para = True
flag_ordered = False
if "atom_ordered_index" in dict_crystal_keys:
f_m_perp_o_ccs, dder_f_m_perp_o_ccs = calc_f_m_perp_ordered_by_dictionary(
dict_crystal,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_f_m_perp_o = len(dder_f_m_perp_o_ccs.keys()) > 0
flag_ordered = True
flag_matrix_t = flag_unit_cell_parameters
matrix_t, dder_matrix_t = calc_matrix_t(
index_hkl,
unit_cell_parameters,
flag_unit_cell_parameters=flag_unit_cell_parameters)
f_m_perp_o, dder_f_m_perp_o = calc_m_v(
matrix_t,
f_m_perp_o_ccs,
flag_m=flag_unit_cell_parameters,
flag_v=flag_f_m_perp_o)
if flag_para and not (flag_ordered):
flag_iint_plus_minus = flag_f_nucl or flag_tensor_sigma or flags_beam_polarization or flags_flipper_efficiency
if (("iint_plus" in dict_in_out_phase_keys)
and ("iint_minu" in dict_in_out_phase_keys)
and flag_use_precalculated_data
and not (flag_iint_plus_minus)):
iint_plus, iint_minus = dict_in_out_phase[
"iint_plus"], dict_in_out_phase["iint_minus"]
else:
iint_plus, iint_minus, dder_plus, dder_minus = calc_powder_iint_1d_para(
f_nucl,
tensor_sigma,
beam_polarization,
flipper_efficiency,
magnetic_field,
flag_f_nucl=flag_f_nucl,
flag_tensor_sigma=flag_tensor_sigma,
flag_polarization=flags_beam_polarization,
flag_flipper=flags_flipper_efficiency)
elif not (flag_para) and flag_ordered:
flag_iint_plus_minus = flag_f_nucl or flag_f_m_perp_o or flags_beam_polarization or flags_flipper_efficiency
if (("iint_plus" in dict_in_out_phase_keys)
and ("iint_minus" in dict_in_out_phase_keys)
and flag_use_precalculated_data
and not (flag_iint_plus_minus)):
iint_plus, iint_minus = dict_in_out_phase[
"iint_plus"], dict_in_out_phase["iint_minus"]
else:
iint_plus, dder_plus = calc_powder_iint_1d_ordered(
f_nucl,
f_m_perp_o,
flag_f_nucl=flag_f_nucl
and flag_calc_analytical_derivatives,
flag_f_m_perp=flag_f_m_perp_o
and flag_calc_analytical_derivatives)
iint_minus = iint_plus
dder_minus = dder_plus
elif flag_para and flag_ordered:
flag_iint_plus_minus = flag_f_nucl or flag_tensor_sigma or flag_f_m_perp_o or flags_beam_polarization or flags_flipper_efficiency
if (("iint_plus" in dict_in_out_phase_keys)
and ("iint_minu" in dict_in_out_phase_keys)
and flag_use_precalculated_data
and not (flag_iint_plus_minus)):
iint_plus, iint_minus = dict_in_out_phase[
"iint_plus"], dict_in_out_phase["iint_minus"]
else:
iint_plus, iint_minus, dder_plus, dder_minus = calc_powder_iint_1d_mix(
f_nucl,
f_m_perp_o,
tensor_sigma,
beam_polarization,
flipper_efficiency,
magnetic_field,
flag_f_nucl=flag_f_nucl
and flag_calc_analytical_derivatives,
flag_f_m_perp_ordered=flag_f_m_perp_o
and flag_calc_analytical_derivatives,
flag_tensor_sigma=flag_tensor_sigma
and flag_calc_analytical_derivatives,
flag_polarization=flags_beam_polarization
and flag_calc_analytical_derivatives,
flag_flipper=flags_flipper_efficiency
and flag_calc_analytical_derivatives)
else:
iint_plus = numpy.square(numpy.abs(f_nucl))
iint_minus = numpy.square(numpy.abs(f_nucl))
dict_in_out_phase["iint_plus"] = iint_plus
dict_in_out_phase["iint_minus"] = iint_minus
elif radiation[0].startswith("X-rays"):
f_charge, dder_f_charge = calc_f_charge_by_dictionary(
dict_crystal,
wavelength,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_f_charge = len(dder_f_charge.keys()) > 0
iint = numpy.square(numpy.abs(f_charge))
# FIXME: preparation for XMD
iint_plus = iint
iint_minus = iint
dict_in_out_phase["iint_plus"] = iint_plus
dict_in_out_phase["iint_minus"] = iint_minus
if flag_phase_texture:
flag_texture_g1 = numpy.any(flags_texture_g1)
flag_texture_g2 = numpy.any(flags_texture_g2)
flag_texture_axis = numpy.any(flags_texture_axis)
flag_hh = numpy.any(
[flag_texture_g1, flag_texture_g2, flag_texture_axis])
if (flag_use_precalculated_data
and ("preferred_orientation" in dict_in_out_phase_keys)
and not (flag_hh)):
preferred_orientation = dict_in_out_phase[
"preferred_orientation"]
else:
preferred_orientation, dder_po = calc_preferred_orientation_pd(
index_hkl,
texture_g1,
texture_g2,
texture_axis,
unit_cell_parameters,
flag_texture_g1=flag_texture_g1
and flag_calc_analytical_derivatives,
flag_texture_g2=flag_texture_g2
and flag_calc_analytical_derivatives,
flag_texture_axis=flag_texture_axis
and flag_calc_analytical_derivatives)
dict_in_out_phase[
"preferred_orientation"] = preferred_orientation
flag_rp = numpy.any(flags_p_resolution) or numpy.any(
flags_resolution_parameters)
hh = resolution_parameters + p_resolution
u, v, w, x, y = hh[0], hh[1], hh[2], hh[3], hh[4]
p_1, p_2, p_3, p_4 = asymmetry_parameters[0], asymmetry_parameters[
1], asymmetry_parameters[2], asymmetry_parameters[3]
profile_pv, dder_pv = calc_profile_pseudo_voight(
ttheta_zs,
ttheta_hkl,
u,
v,
w,
p_ig,
x,
y,
p_1,
p_2,
p_3,
p_4,
flag_ttheta=flags_offset_ttheta,
flag_ttheta_hkl=flag_ttheta_hkl,
flag_u=flag_rp,
flag_v=flag_rp,
flag_w=flag_rp,
flag_i_g=flags_p_ig,
flag_x=flag_rp,
flag_y=flag_rp,
flag_p_1=flag_asymmetry_parameters,
flag_p_2=flag_asymmetry_parameters,
flag_p_3=flag_asymmetry_parameters,
flag_p_4=flag_asymmetry_parameters)
dict_in_out_phase["profile_pv"] = profile_pv
# flags_p_scale
iint_m_plus = iint_plus * multiplicity_hkl
iint_m_minus = iint_minus * multiplicity_hkl
lf = calc_lorentz_factor(ttheta_hkl, k=k, cthm=cthm,
flag_ttheta=None)[0]
dict_in_out_phase[
"iint_plus_with_factors"] = 0.5 * p_scale * lf * iint_m_plus
dict_in_out_phase[
"iint_minus_with_factors"] = 0.5 * p_scale * lf * iint_m_minus
if flag_texture:
# 0.5 to have the same meaning for the scale factor as in FullProf
signal_plus = 0.5 * p_scale * lorentz_factor * (
profile_pv * (iint_m_plus * preferred_orientation)[na, :]).sum(
axis=1) # sum over hkl
signal_minus = 0.5 * p_scale * lorentz_factor * (
profile_pv *
(iint_m_minus * preferred_orientation)[na, :]).sum(axis=1)
dict_in_out_phase[
"iint_plus_with_factors"] *= preferred_orientation
dict_in_out_phase[
"iint_minus_with_factors"] *= preferred_orientation
else:
signal_plus = 0.5 * p_scale * lorentz_factor * (
profile_pv * iint_m_plus[na, :]).sum(axis=1)
signal_minus = 0.5 * p_scale * lorentz_factor * (
profile_pv * iint_m_minus[na, :]).sum(axis=1)
dict_in_out_phase["signal_plus"] = signal_plus
dict_in_out_phase["signal_minus"] = signal_minus
total_signal_plus += signal_plus
total_signal_minus += signal_minus
if flag_dict:
dict_in_out["signal_plus"] = total_signal_plus
dict_in_out["signal_minus"] = total_signal_minus
if ("signal_exp_plus" in dict_pd_keys) and ("signal_exp_minus"
in dict_pd_keys):
signal_exp_plus = dict_pd["signal_exp_plus"]
signal_exp_minus = dict_pd["signal_exp_minus"]
if flag_dict:
dict_in_out["signal_exp_plus"] = signal_exp_plus
dict_in_out["signal_exp_minus"] = signal_exp_minus
flag_chi_sq_sum, flag_chi_sq_difference = True, True
if "flag_chi_sq_sum" in dict_pd_keys:
flag_chi_sq_sum = dict_pd["flag_chi_sq_sum"]
if "flag_chi_sq_difference" in dict_pd_keys:
flag_chi_sq_difference = dict_pd["flag_chi_sq_difference"]
if flag_chi_sq_sum:
signal_exp = signal_exp_plus[0, :] + signal_exp_minus[0, :]
signal_sigma = numpy.sqrt(
numpy.square(signal_exp_plus[1, :]) +
numpy.square(signal_exp_minus[1, :]))
else:
signal_exp = dict_pd["signal_exp"][0, :]
signal_sigma = dict_pd["signal_exp"][1, :]
if flag_dict:
dict_in_out["signal_exp"] = dict_pd["signal_exp"]
flag_chi_sq_sum = True
flag_chi_sq_difference = False
chi_sq = 0.
n_point = 0
if flag_chi_sq_sum:
in_points = numpy.logical_not(excluded_points)
total_signal_sum = total_signal_plus + total_signal_minus + signal_background
chi_sq_sum = ((numpy.square(
(signal_exp - total_signal_sum) / signal_sigma) *
in_points)).sum(axis=0)
chi_sq += chi_sq_sum
n_point += numpy.sum(in_points)
if flag_chi_sq_difference:
signal_exp_diff = signal_exp_plus[0, :] - signal_exp_minus[0, :]
signal_sigma_diff = numpy.sqrt(
numpy.square(signal_exp_plus[1, :]) +
numpy.square(signal_exp_minus[1, :]))
total_signal_diff = total_signal_plus - total_signal_minus
chi_sq_diff = (numpy.square((signal_exp_diff - total_signal_diff) /
signal_sigma_diff)).sum(axis=0)
chi_sq += chi_sq_diff
n_point += signal_exp_diff.shape[0]
if numpy.isnan(chi_sq):
chi_sq = 1e30
flags_pd = get_flags(dict_pd)
l_flags_crystal = [
get_flags(dict_crystal) for dict_crystal in dict_crystals
]
l_parameter_name = []
for way, flags in flags_pd.items():
pd_type_name = dict_pd["type_name"]
ind_1d = numpy.atleast_1d(numpy.argwhere(flags)) #.flatten()
parameter_name = [(pd_type_name, ) + way + (tuple(ind_1d[ind, :]), )
for ind in range(ind_1d.shape[0])]
l_parameter_name.extend(parameter_name)
for flags_crystal, dict_crystal in zip(l_flags_crystal, dict_crystals):
for way, flags in flags_crystal.items():
crystal_type_name = dict_crystal["type_name"]
ind_1d = numpy.atleast_1d(numpy.argwhere(flags)) #.flatten()
parameter_name = [
(crystal_type_name, ) + way + (tuple(ind_1d[ind, :]), )
for ind in range(ind_1d.shape[0])
]
l_parameter_name.extend(parameter_name)
if flag_background_intensity:
pass
der_chi_sq = numpy.zeros((len(l_parameter_name), ), dtype=float)
dder_chi_sq = numpy.zeros((len(l_parameter_name), len(l_parameter_name)),
dtype=float)
return chi_sq, n_point, der_chi_sq, dder_chi_sq, l_parameter_name
def calc_chi_sq_for_pd2d_by_dictionary(
dict_pd,
dict_crystals,
dict_in_out: dict = None,
flag_use_precalculated_data: bool = False,
flag_calc_analytical_derivatives: bool = False):
"""Calculate chi_sq for diffrn experiment.
"""
if dict_in_out is None:
flag_dict = False
flag_use_precalculated_data = False
dict_in_out_keys = []
else:
flag_dict = True
dict_in_out_keys = dict_in_out.keys()
dict_pd_keys = dict_pd.keys()
phase_name = [hh["name"].lower() for hh in dict_crystals]
excluded_points = dict_pd["excluded_points"]
dict_in_out["excluded_points"] = excluded_points
gamma = dict_pd["gamma"]
nu = dict_pd["nu"]
offset_gamma = dict_pd["offset_gamma"]
offset_nu = dict_pd["offset_nu"]
flags_offset_gamma = dict_pd["flags_offset_gamma"]
flags_offset_nu = dict_pd["flags_offset_nu"]
gamma_zs = gamma - offset_gamma
nu_zs = nu - offset_nu
dict_in_out["gamma"] = gamma_zs
dict_in_out["nu"] = nu_zs
wavelength = dict_pd["wavelength"]
flags_wavelength = dict_pd["flags_wavelength"]
magnetic_field = dict_pd["magnetic_field"]
flag_polarized, flag_unpolarized = False, False
if "signal_exp_plus" in dict_pd_keys:
flag_polarized = True
elif "signal_exp" in dict_pd_keys:
flag_unpolarized = True
if flag_polarized:
beam_polarization = dict_pd["beam_polarization"]
flipper_efficiency = dict_pd["flipper_efficiency"]
flags_beam_polarization = dict_pd["flags_beam_polarization"]
flags_flipper_efficiency = dict_pd["flags_flipper_efficiency"]
elif flag_unpolarized:
beam_polarization = numpy.array([
0.,
], dtype=float)
flipper_efficiency = numpy.array([
0.,
], dtype=float)
flags_beam_polarization = numpy.array([
False,
], dtype=bool)
flags_flipper_efficiency = numpy.array([
False,
], dtype=bool)
alpha_det = numpy.arccos(
numpy.sin(nu_zs)[na, :] /
numpy.sqrt(2 -
2 * numpy.cos(gamma_zs)[:, na] * numpy.cos(nu_zs)[na, :]))
dict_in_out["alpha_detector"] = alpha_det
flag_ttheta = flags_offset_gamma or flags_offset_nu
ttheta_zs, phi_zs, dder_ttheta_zs, dder_phi_zs = calc_ttheta_phi_by_gamma_nu(
gamma_zs[:, na],
nu_zs[na, :],
flag_gamma=flags_offset_gamma,
flag_nu=flags_offset_nu)
ttheta_min = calc_ttheta_phi_by_gamma_nu(gamma_zs.min(),
0.,
flag_gamma=False,
flag_nu=False)[0]
ttheta_max = calc_ttheta_phi_by_gamma_nu(gamma_zs.max(),
nu_zs.max(),
flag_gamma=False,
flag_nu=False)[0]
sthovl_min = numpy.sin(0.5 * ttheta_min - numpy.pi / 90.) / wavelength
if sthovl_min < 0:
sthovl_min = 0.00001
sthovl_max = numpy.sin(0.5 * ttheta_max + numpy.pi / 90.) / wavelength
background_gamma = dict_pd["background_gamma"]
background_nu = dict_pd["background_nu"]
background_intensity = dict_pd["background_intensity"]
flags_background_intensity = dict_pd["flags_background_intensity"]
flag_background_intensity = numpy.any(flags_background_intensity)
if (flag_use_precalculated_data and ("signal_background" in dict_in_out)
and not (flag_background_intensity)):
signal_background = dict_in_out["signal_background"]
else:
signal_background, dder_s_bkgr = calc_background(
gamma,
nu,
background_gamma,
background_nu,
background_intensity,
flag_background_intensity=(flag_background_intensity
and flag_calc_analytical_derivatives))
dict_in_out["signal_background"] = signal_background
pd_phase_name = dict_pd["phase_name"]
pd_phase_scale = dict_pd["phase_scale"]
pd_phase_resolution_parameters = dict_pd[
"phase_resolution_parameters"] # U_phase, V_phase, W_phase, X_phase, Y_phase
pd_phase_ig = dict_pd["phase_ig"] # IG_phase
flags_pd_phase_scale = dict_pd["flags_phase_scale"]
flags_pd_phase_resolution_parameters = dict_pd[
"flags_phase_resolution_parameters"] # U_phase, V_phase, W_phase, X_phase, Y_phase
flags_pd_phase_ig = dict_pd["flags_phase_ig"] # IG_phase
resolution_parameters = dict_pd["resolution_parameters"] # U, V, W, X, Y
asymmetry_parameters = dict_pd["asymmetry_parameters"] # p1, p2, p3, p4
p_phi = dict_pd["resolution_phi_parameter"]
flag_p_phi = dict_pd["flags_resolution_phi_parameter"]
flags_resolution_parameters = dict_pd["flags_resolution_parameters"]
flags_asymmetry_parameters = dict_pd["flags_asymmetry_parameters"]
flag_asymmetry_parameters = numpy.any(flags_asymmetry_parameters)
if "texture_name" in dict_pd_keys:
flag_texture = True
pd_texture_name = dict_pd["texture_name"]
pd_texture_g1 = dict_pd["texture_g1"]
pd_texture_g2 = dict_pd["texture_g2"]
pd_texture_axis = dict_pd["texture_axis"]
pd_flags_texture_g1 = dict_pd["flags_texture_g1"]
pd_flags_texture_g2 = dict_pd["flags_texture_g2"]
pd_flags_texture_axis = dict_pd["flags_texture_axis"]
else:
flag_texture = False
lorentz_factor, dder_lf = calc_lorentz_factor(ttheta_zs,
flag_ttheta=flag_ttheta)
dict_in_out["lorentz_factor"] = lorentz_factor
total_signal_plus = numpy.zeros_like(ttheta_zs)
total_signal_minus = numpy.zeros_like(ttheta_zs)
for p_name, p_scale, p_resolution, p_ig, flags_p_scale, flags_p_resolution, flags_p_ig in zip(
pd_phase_name, pd_phase_scale,
pd_phase_resolution_parameters.transpose(), pd_phase_ig,
flags_pd_phase_scale,
flags_pd_phase_resolution_parameters.transpose(),
flags_pd_phase_ig):
p_name = p_name.lower()
flag_phase_texture = False
if flag_texture:
ind_texture = numpy.argwhere(pd_texture_name == p_name)
if ind_texture.shape[0] != 0:
texture_g1 = pd_texture_g1[ind_texture[0]]
texture_g2 = pd_texture_g2[ind_texture[0]]
texture_axis = pd_texture_axis[:, ind_texture[0]]
flag_phase_texture = True
flags_texture_g1 = pd_flags_texture_g1[ind_texture[0]]
flags_texture_g2 = pd_flags_texture_g2[ind_texture[0]]
flags_texture_axis = pd_flags_texture_axis[:, ind_texture[0]]
ind_phase = phase_name.index(p_name)
dict_crystal = dict_crystals[ind_phase]
dict_crystal_keys = dict_crystal.keys()
dict_in_out_keys = dict_in_out.keys()
if f"dict_in_out_{p_name:}" in dict_in_out_keys:
dict_in_out_phase = dict_in_out[f"dict_in_out_{p_name:}"]
else:
dict_in_out_phase = {}
dict_in_out[f"dict_in_out_{p_name:}"] = dict_in_out_phase
dict_in_out_phase_keys = dict_in_out_phase.keys()
if "reduced_symm_elems" in dict_crystal_keys:
reduced_symm_elems = dict_crystal["reduced_symm_elems"]
translation_elems = dict_crystal["translation_elems"]
elif "full_symm_elems" in dict_crystal_keys:
full_symm_elems = dict_crystal["full_symm_elems"]
elif "full_mcif_elems" in dict_crystal_keys:
full_mcif_elems = dict_crystal["full_mcif_elems"]
unit_cell_parameters = dict_crystal["unit_cell_parameters"]
flags_unit_cell_parameters = dict_crystal["flags_unit_cell_parameters"]
flag_unit_cell_parameters = numpy.any(flags_unit_cell_parameters)
if flag_unit_cell_parameters:
sc_uc = dict_crystal["sc_uc"]
v_uc = dict_crystal["v_uc"]
unit_cell_parameters = numpy.dot(sc_uc,
unit_cell_parameters) + v_uc
if (flag_use_precalculated_data
and ("index_hkl" in dict_in_out_phase_keys)
and ("multiplicity_hkl" in dict_in_out_phase_keys)
and not (flag_unit_cell_parameters or flag_ttheta)):
index_hkl = dict_in_out_phase["index_hkl"]
multiplicity_hkl = dict_in_out_phase["multiplicity_hkl"]
else:
if flag_phase_texture:
reduced_symm_elems_p1 = numpy.array(
[[0], [0], [0], [1], [1], [0], [0], [0], [1], [0], [0],
[0], [1]],
dtype=int)
translation_elems_p1 = numpy.array([[0], [0], [0], [1]],
dtype=int)
index_hkl, multiplicity_hkl = calc_index_hkl_multiplicity_in_range(
sthovl_min, sthovl_max, unit_cell_parameters,
reduced_symm_elems_p1, translation_elems_p1, False)
# index_hkl = numpy.reshape(numpy.stack([index_hkl, -1*index_hkl], axis=2), (3, 2*index_hkl.shape[1]))
# multiplicity_hkl = numpy.ones_like(index_hkl[0])
else:
if "reduced_symm_elems" in dict_crystal_keys:
centrosymmetry = dict_crystal["centrosymmetry"]
index_hkl, multiplicity_hkl = calc_index_hkl_multiplicity_in_range(
sthovl_min, sthovl_max, unit_cell_parameters,
reduced_symm_elems, translation_elems, centrosymmetry)
else:
translation_elems_p1 = numpy.array([[0], [0], [0], [1]],
dtype=int)
index_hkl, multiplicity_hkl = calc_index_hkl_multiplicity_in_range(
sthovl_min, sthovl_max, unit_cell_parameters,
full_mcif_elems[:13], translation_elems_p1, False)
if (("index_hkl" in dict_in_out_phase_keys)
and flag_use_precalculated_data):
if index_hkl.shape != dict_in_out_phase["index_hkl"].shape:
flag_use_precalculated_data = False
else:
flag_use_precalculated_data = numpy.all(
numpy.logical_and(dict_in_out_phase["index_hkl"],
index_hkl))
dict_in_out_phase["index_hkl"] = index_hkl
dict_in_out_phase["multiplicity_hkl"] = multiplicity_hkl
flag_sthovl_hkl = flag_unit_cell_parameters
sthovl_hkl, dder_sthovl_hkl = calc_sthovl_by_unit_cell_parameters(
index_hkl,
unit_cell_parameters,
flag_unit_cell_parameters=flag_unit_cell_parameters)
flag_ttheta_hkl = flag_sthovl_hkl or flags_wavelength
ttheta_hkl = 2 * numpy.arcsin(wavelength * sthovl_hkl)
dict_in_out_phase["ttheta_hkl"] = ttheta_hkl
f_nucl, dder_f_nucl = calc_f_nucl_by_dictionary(
dict_crystal,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_f_nucl = len(dder_f_nucl.keys()) > 0
flag_para = False
if "atom_para_index" in dict_crystal_keys:
sft_ccs, dder_sft_ccs = calc_sft_ccs_by_dictionary(
dict_crystal,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_sft_ccs = len(dder_sft_ccs.keys()) > 0
flag_matrix_t = flag_unit_cell_parameters
matrix_t, dder_matrix_t = calc_matrix_t(
index_hkl,
unit_cell_parameters,
flag_unit_cell_parameters=flag_unit_cell_parameters)
flag_tensor_sigma = flag_sft_ccs or flag_unit_cell_parameters
tensor_sigma, dder_tensor_sigma = calc_m1_m2_m1t(
matrix_t,
sft_ccs,
flag_m1=flag_sft_ccs,
flag_m2=flag_unit_cell_parameters)
flag_para = True
flag_ordered = False
if "atom_ordered_index" in dict_crystal_keys:
f_m_perp_o_ccs, dder_f_m_perp_o_ccs = calc_f_m_perp_ordered_by_dictionary(
dict_crystal,
dict_in_out_phase,
flag_use_precalculated_data=flag_use_precalculated_data)
flag_f_m_perp_o = len(dder_f_m_perp_o_ccs.keys()) > 0
flag_ordered = True
flag_matrix_t = flag_unit_cell_parameters
matrix_t, dder_matrix_t = calc_matrix_t(
index_hkl,
unit_cell_parameters,
flag_unit_cell_parameters=flag_unit_cell_parameters)
f_m_perp_o, dder_f_m_perp_o = calc_m_v(
matrix_t,
f_m_perp_o_ccs,
flag_m=flag_unit_cell_parameters,
flag_v=flag_f_m_perp_o)
if flag_para and not (flag_ordered):
flag_iint_plus_minus = flag_f_nucl or flag_tensor_sigma or flags_beam_polarization or flags_flipper_efficiency
if (("iint_plus" in dict_in_out_phase_keys)
and ("iint_minu" in dict_in_out_phase_keys)
and flag_use_precalculated_data
and not (flag_iint_plus_minus)):
iint_plus, iint_minus = dict_in_out_phase[
"iint_plus"], dict_in_out_phase["iint_minus"]
else:
iint_plus, iint_minus, dder_plus, dder_minus = calc_powder_iint_2d_para(
f_nucl,
tensor_sigma,
beam_polarization,
flipper_efficiency,
magnetic_field,
alpha_det,
dict_in_out_phase,
flag_f_nucl=flag_f_nucl
and flag_calc_analytical_derivatives,
flag_tensor_sigma=flag_tensor_sigma
and flag_calc_analytical_derivatives,
flag_polarization=flags_beam_polarization
and flag_calc_analytical_derivatives,
flag_flipper=flags_flipper_efficiency
and flag_calc_analytical_derivatives)
elif not (flag_para) and flag_ordered:
flag_iint_plus_minus = flag_f_nucl or flag_f_m_perp_o or flags_beam_polarization or flags_flipper_efficiency
if (("iint_plus" in dict_in_out_phase_keys)
and ("iint_minus" in dict_in_out_phase_keys)
and flag_use_precalculated_data
and not (flag_iint_plus_minus)):
iint_plus, iint_minus = dict_in_out_phase[
"iint_plus"], dict_in_out_phase["iint_minus"]
else:
iint_plus, iint_minus, dder_plus, dder_minus = calc_powder_iint_2d_ordered(
f_nucl,
f_m_perp_o,
beam_polarization,
flipper_efficiency,
alpha_det,
dict_in_out_phase,
flag_f_nucl=flag_f_nucl
and flag_calc_analytical_derivatives,
flag_f_m_perp=flag_f_m_perp_o
and flag_calc_analytical_derivatives,
flag_polarization=flags_beam_polarization
and flag_calc_analytical_derivatives,
flag_flipper=flags_flipper_efficiency
and flag_calc_analytical_derivatives)
elif flag_para and flag_ordered:
flag_iint_plus_minus = flag_f_nucl or flag_tensor_sigma or flag_f_m_perp_o or flags_beam_polarization or flags_flipper_efficiency
if (("iint_plus" in dict_in_out_phase_keys)
and ("iint_minu" in dict_in_out_phase_keys)
and flag_use_precalculated_data
and not (flag_iint_plus_minus)):
iint_plus, iint_minus = dict_in_out_phase[
"iint_plus"], dict_in_out_phase["iint_minus"]
else:
iint_plus, iint_minus, dder_plus, dder_minus = calc_powder_iint_2d_mix(
f_nucl,
tensor_sigma,
f_m_perp_o,
beam_polarization,
flipper_efficiency,
magnetic_field,
alpha_det,
dict_in_out_phase,
flag_f_nucl=flag_f_nucl
and flag_calc_analytical_derivatives,
flag_tensor_sigma=flag_tensor_sigma
and flag_calc_analytical_derivatives,
flag_f_m_perp_ordered=flag_f_m_perp_o
and flag_calc_analytical_derivatives,
flag_polarization=flags_beam_polarization
and flag_calc_analytical_derivatives,
flag_flipper=flags_flipper_efficiency
and flag_calc_analytical_derivatives)
else:
iint_plus = numpy.square(numpy.abs(f_nucl))
iint_minus = numpy.square(numpy.abs(f_nucl))
dict_in_out_phase["iint_plus"] = iint_plus
dict_in_out_phase["iint_minus"] = iint_minus
if flag_phase_texture:
flag_texture_g1 = numpy.any(flags_texture_g1)
flag_texture_g2 = numpy.any(flags_texture_g2)
flag_texture_axis = numpy.any(flags_texture_axis)
flag_hh = numpy.any(
[flag_texture_g1, flag_texture_g2, flag_texture_axis])
if (flag_use_precalculated_data
and ("preferred_orientation" in dict_in_out_phase_keys)
and not (flag_hh)):
preferred_orientation = dict_in_out_phase[
"preferred_orientation"]
else:
preferred_orientation, dder_po = calc_preferred_orientation_pd2d(
alpha_det,
index_hkl,
texture_g1,
texture_g2,
texture_axis,
unit_cell_parameters,
flag_texture_g1=flag_texture_g1
and flag_calc_analytical_derivatives,
flag_texture_g2=flag_texture_g2
and flag_calc_analytical_derivatives,
flag_texture_axis=flag_texture_axis
and flag_calc_analytical_derivatives)
dict_in_out_phase[
"preferred_orientation"] = preferred_orientation
# it is not necessary calculations but it is better to now (gamma,nu)_max of peaks
eq_axis = calc_eq_ccs_by_unit_cell_parameters(
texture_axis,
unit_cell_parameters,
flag_unit_cell_parameters=False)[0]
if "eq_ccs" in dict_in_out_phase_keys:
eq_ccs = dict_in_out_phase["eq_ccs"]
else:
eq_ccs = calc_eq_ccs_by_unit_cell_parameters(
index_hkl,
unit_cell_parameters=unit_cell_parameters,
flag_unit_cell_parameters=False)[0]
dict_in_out_phase["eq_ccs"] = eq_ccs
ttheta_hkl = dict_in_out_phase["ttheta_hkl"]
gamma_hkl, nu_hkl = calc_gamma_nu_for_textured_peaks(
eq_axis, eq_ccs, ttheta_hkl, texture_g1)
dict_in_out_phase["gamma_hkl"] = gamma_hkl
dict_in_out_phase["nu_hkl"] = nu_hkl
flag_rp = numpy.any(flags_p_resolution) or numpy.any(
flags_resolution_parameters)
hh = resolution_parameters + p_resolution
u, v, w, x, y = hh[0], hh[1], hh[2], hh[3], hh[4]
p_1, p_2, p_3, p_4 = asymmetry_parameters[0], asymmetry_parameters[
1], asymmetry_parameters[2], asymmetry_parameters[3]
flag_profile_pv = flag_rp or flag_asymmetry_parameters or flag_p_phi
if flag_use_precalculated_data and (
"profile_pv" in dict_in_out_keys) and not (flag_profile_pv):
profile_pv = dict_in_out_phase["profile_pv"]
else:
profile_pv, dder_pv = calc_profile_pseudo_voight_2d(
ttheta_zs,
phi_zs,
ttheta_hkl,
u,
v,
w,
p_ig,
x,
y,
p_1,
p_2,
p_3,
p_4,
p_phi,
flag_ttheta=flag_ttheta,
flag_ttheta_hkl=flag_ttheta_hkl,
flag_u=flag_rp,
flag_v=flag_rp and flag_calc_analytical_derivatives,
flag_w=flag_rp and flag_calc_analytical_derivatives,
flag_i_g=flags_p_ig and flag_calc_analytical_derivatives,
flag_x=flag_rp and flag_calc_analytical_derivatives,
flag_y=flag_rp and flag_calc_analytical_derivatives,
flag_p_1=flag_asymmetry_parameters
and flag_calc_analytical_derivatives,
flag_p_2=flag_asymmetry_parameters
and flag_calc_analytical_derivatives,
flag_p_3=flag_asymmetry_parameters
and flag_calc_analytical_derivatives,
flag_p_4=flag_asymmetry_parameters
and flag_calc_analytical_derivatives,
flag_p_phi=flag_p_phi and flag_calc_analytical_derivatives)
dict_in_out_phase["profile_pv"] = profile_pv
# flags_p_scale
iint_m_plus = iint_plus * multiplicity_hkl
iint_m_minus = iint_minus * multiplicity_hkl
if flag_phase_texture:
# 0.5 to have the same meaning for the scale factor as in FullProf
signal_plus = 0.5 * p_scale * lorentz_factor * (
profile_pv * iint_m_plus * preferred_orientation).sum(
axis=2) # sum over hkl
signal_minus = 0.5 * p_scale * lorentz_factor * (
profile_pv * iint_m_minus * preferred_orientation).sum(axis=2)
else:
signal_plus = 0.5 * p_scale * lorentz_factor * (
profile_pv * iint_m_plus).sum(axis=2)
signal_minus = 0.5 * p_scale * lorentz_factor * (
profile_pv * iint_m_minus).sum(axis=2)
dict_in_out_phase["signal_plus"] = signal_plus
dict_in_out_phase["signal_minus"] = signal_minus
total_signal_plus += signal_plus
total_signal_minus += signal_minus
dict_in_out["signal_plus"] = total_signal_plus
dict_in_out["signal_minus"] = total_signal_minus
if flag_polarized:
signal_exp_plus = dict_pd["signal_exp_plus"]
signal_exp_minus = dict_pd["signal_exp_minus"]
dict_in_out["signal_exp_plus"] = signal_exp_plus
dict_in_out["signal_exp_minus"] = signal_exp_minus
flag_chi_sq_sum = dict_pd["flag_chi_sq_sum"]
flag_chi_sq_difference = dict_pd["flag_chi_sq_difference"]
elif flag_unpolarized:
signal_exp = dict_pd["signal_exp"]
dict_in_out["signal_exp"] = signal_exp
flag_chi_sq_sum = True
flag_chi_sq_difference = False
chi_sq = 0.
n_point = 0
if flag_chi_sq_sum:
in_points = numpy.logical_not(excluded_points)
if flag_polarized:
signal_exp_sum = signal_exp_plus[0, :] + signal_exp_minus[0, :]
signal_sigma_sum = numpy.sqrt(
numpy.square(signal_exp_plus[1, :]) +
numpy.square(signal_exp_minus[1, :]))
elif flag_unpolarized:
signal_exp_sum = signal_exp[0, :]
signal_sigma_sum = signal_exp[1, :]
nan_points_sum = numpy.logical_not(numpy.isnan(signal_exp_sum))
in_points = numpy.logical_and(in_points, nan_points_sum)
total_signal_sum = (total_signal_plus + total_signal_minus)
diff_signal_sum = signal_exp_sum - total_signal_sum - signal_background
inv_sigma_sq_sum = numpy.square(1. / signal_sigma_sum)
chi_sq_sum = numpy.sum(
numpy.square(diff_signal_sum[in_points]) *
inv_sigma_sq_sum[in_points])
chi_sq += chi_sq_sum
n_point += numpy.sum(in_points)
if flag_chi_sq_difference:
signal_exp_diff = signal_exp_plus[0, :] - signal_exp_minus[0, :]
signal_sigma_diff = numpy.sqrt(
numpy.square(signal_exp_plus[1, :]) +
numpy.square(signal_exp_minus[1, :]))
total_signal_diff = total_signal_plus - total_signal_minus
nan_points_diff = numpy.logical_not(numpy.isnan(signal_exp_diff))
chi_sq_diff = numpy.sum(
numpy.square(
(signal_exp_diff - total_signal_diff)[nan_points_diff] /
signal_sigma_diff[nan_points_diff]))
chi_sq += chi_sq_diff
n_point += numpy.sum(nan_points_diff)
if numpy.isnan(chi_sq):
chi_sq = 1e30
flags_pd2d = get_flags(dict_pd)
l_flags_crystal = [
get_flags(dict_crystal) for dict_crystal in dict_crystals
]
dder_signal_pd2d_sum = {}
dder_signal_pd2d_difference = {}
if flag_calc_analytical_derivatives:
if flag_background_intensity:
dder_signal_pd2d_sum['background_intensity'] = dder_s_bkgr[
'background_intensity']
dder_signal_pd2d_sum_keys = dder_signal_pd2d_sum.keys()
dder_signal_pd2d_difference_keys = dder_signal_pd2d_difference.keys()
l_dder_plus_p = []
l_parameter_name = []
for way, flags in flags_pd2d.items():
if flag_calc_analytical_derivatives:
name = way[0]
if name in dder_signal_pd2d_sum_keys:
dder_plus_p = dder_signal_pd2d_sum[name][:, :, flags]
l_dder_plus_p.append(dder_plus_p)
pd_type_name = dict_pd["type_name"]
ind_1d = numpy.atleast_1d(numpy.argwhere(flags)) #.flatten()
parameter_name = [(pd_type_name, ) + way + (tuple(ind_1d[ind, :]), )
for ind in range(ind_1d.shape[0])]
l_parameter_name.extend(parameter_name)
for flags_crystal, dict_crystal in zip(l_flags_crystal, dict_crystals):
for way, flags in flags_crystal.items():
crystal_type_name = dict_crystal["type_name"]
ind_1d = numpy.atleast_1d(numpy.argwhere(flags)) #.flatten()
parameter_name = [
(crystal_type_name, ) + way + (tuple(ind_1d[ind, :]), )
for ind in range(ind_1d.shape[0])
]
l_parameter_name.extend(parameter_name)
der_chi_sq = numpy.zeros((len(l_parameter_name), ), dtype=float)
dder_chi_sq = numpy.zeros((len(l_parameter_name), len(l_parameter_name)),
dtype=float)
if flag_calc_analytical_derivatives:
if len(l_dder_plus_p) > 0:
dder_plus_p = numpy.concatenate(l_dder_plus_p, axis=2)
if flag_chi_sq_sum:
der_chi_sq = (
((-2. * diff_signal_sum * inv_sigma_sq_sum)[:, :, na] *
dder_plus_p).sum(axis=1)).sum(axis=0)
dder_chi_sq = ((2 * dder_plus_p[:, :, :, na] *
dder_plus_p[:, :, na, :]).sum(axis=1)).sum(
axis=0)
return chi_sq, n_point, der_chi_sq, dder_chi_sq, l_parameter_name