def calculate_scales_and_derivatives(self, block_id=0):
if self._n_refl[block_id] > 1:
value, weight, sumweight = self._smoother.multi_value_weight(
self._normalised_x_values[block_id],
self._normalised_y_values[block_id],
self._normalised_z_values[block_id],
self.value,
)
inv_sw = 1.0 / sumweight
dv_dp = row_multiply(weight, inv_sw)
elif self._n_refl[block_id] == 1:
value, weight, sumweight = self._smoother.value_weight(
self._normalised_x_values[block_id][0],
self._normalised_y_values[block_id][0],
self._normalised_z_values[block_id][0],
self.value,
)
dv_dp = sparse.matrix(1, weight.size)
b = flex.double(weight.as_dense_vector() / sumweight)
b.reshape(flex.grid(1, b.size()))
dv_dp.assign_block(b, 0, 0)
value = flex.double(1, value)
else:
return flex.double([]), sparse.matrix(0, 0)
return value, dv_dp
def calculate_scales_and_derivatives(self, block_id=0):
scales, derivatives = super(
SmoothBScaleComponent1D, self
).calculate_scales_and_derivatives(block_id)
if self._n_refl[block_id] == 0:
return flex.double([]), sparse.matrix(0, 0)
prefac = 1.0 / (2.0 * (self._d_values[block_id] * self._d_values[block_id]))
s = flex.exp(scales * prefac)
d = row_multiply(derivatives, s * prefac)
return s, d
def _calculate_derivatives(apm, block_id, scales, derivatives_list):
"""Calculate the derivatives matrix."""
if not scales:
return sparse.matrix(0, 0)
if len(scales) == 1:
# only one active parameter, so don't need to chain rule any derivatives
# for block_id in range(len(apm.n_obs)):
return derivatives_list[0]
derivatives = sparse.matrix(apm.n_obs[block_id], apm.n_active_params)
col_idx = 0
for i, d in enumerate(derivatives_list):
scale_multipliers = flex.double(apm.n_obs[block_id], 1.0)
for j, s1 in enumerate(scales):
if i != j:
scale_multipliers *= s1
if apm.constant_g_values:
scale_multipliers *= apm.constant_g_values[block_id]
next_deriv = row_multiply(d, scale_multipliers)
derivatives.assign_block(next_deriv, 0, col_idx)
col_idx += d.n_cols
return derivatives
def calculate_jacobian(Ih_table):
"""Calculate the jacobian matrix, size Ih_table.size by len(self.apm.x)."""
jacobian = row_multiply(Ih_table.derivatives, -1.0 * Ih_table.Ih_values)
return jacobian
