Пример #1
0
  def compute_functional_and_gradients(self):
    u = self.unpack()
    f = scaling.wilson_total_nll_aniso(self.hkl,
                                       self.f_obs,
                                       self.sigma_f_obs,
                                       self.epsilon,
                                       self.sigma_prot_sq,
                                       self.gamma_prot,
                                       self.centric,
                                       self.x[0],
                                       self.unit_cell,
                                       u)
    self.f=f
    g_full_exact = flex.double( scaling.wilson_total_nll_aniso_gradient(
      self.hkl,
      self.f_obs,
      self.sigma_f_obs,
      self.epsilon,
      self.sigma_prot_sq,
      self.gamma_prot,
      self.centric,
      self.x[0],
      self.unit_cell,
      u ))

    g = self.pack(g_full_exact)
    return f, g
Пример #2
0
  def compute_functional_and_gradients(self):
    u = self.unpack()
    f = scaling.wilson_total_nll_aniso(self.hkl,
                                       self.f_obs,
                                       self.sigma_f_obs,
                                       self.epsilon,
                                       self.sigma_prot_sq,
                                       self.gamma_prot,
                                       self.centric,
                                       self.x[0],
                                       self.unit_cell,
                                       u)
    self.f=f
    g_full_exact = flex.double( scaling.wilson_total_nll_aniso_gradient(
      self.hkl,
      self.f_obs,
      self.sigma_f_obs,
      self.epsilon,
      self.sigma_prot_sq,
      self.gamma_prot,
      self.centric,
      self.x[0],
      self.unit_cell,
      u ))

    g = self.pack(g_full_exact)
    return f, g
Пример #3
0
def finite_diffs_aniso(p_scale, u_star, centric=False, h=0.0001):
    d_star_sq = flex.double(2, 0.25)
    f_obs = flex.double(2, 1.0)
    centric_array = flex.bool(2, centric)
    sigma_f_obs = f_obs / 10.0
    sigma_sq = flex.double(2, 1.0)
    epsilon = flex.double(2, 1.0)
    gamma = flex.double(2, 0.0)
    unit_cell = uctbx.unit_cell('20, 30, 40, 90.0, 90.0, 90.0')
    mi = flex.miller_index(((1, 2, 3), (1, 2, 3)))
    xs = crystal.symmetry((20, 30, 40), "P 2 2 2")
    ms = miller.set(xs, mi)

    nll_norm = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                               sigma_f_obs[0], epsilon[0],
                                               sigma_sq[0], gamma[0],
                                               centric_array[0], p_scale,
                                               unit_cell, u_star)

    nll_scale = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                                sigma_f_obs[0], epsilon[0],
                                                sigma_sq[0], gamma[0],
                                                centric_array[0], p_scale + h,
                                                unit_cell, u_star)
    u_star[0] += h
    nll_u11 = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                              sigma_f_obs[0], epsilon[0],
                                              sigma_sq[0], gamma[0],
                                              centric_array[0], p_scale,
                                              unit_cell, u_star)
    u_star[0] -= h
    u_star[1] += h
    nll_u22 = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                              sigma_f_obs[0], epsilon[0],
                                              sigma_sq[0], gamma[0],
                                              centric_array[0], p_scale,
                                              unit_cell, u_star)
    u_star[1] -= h
    u_star[2] += h
    nll_u33 = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                              sigma_f_obs[0], epsilon[0],
                                              sigma_sq[0], gamma[0],
                                              centric_array[0], p_scale,
                                              unit_cell, u_star)
    u_star[2] -= h
    u_star[3] += h
    nll_u12 = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                              sigma_f_obs[0], epsilon[0],
                                              sigma_sq[0], gamma[0],
                                              centric_array[0], p_scale,
                                              unit_cell, u_star)
    u_star[3] -= h
    u_star[4] += h
    nll_u13 = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                              sigma_f_obs[0], epsilon[0],
                                              sigma_sq[0], gamma[0],
                                              centric_array[0], p_scale,
                                              unit_cell, u_star)
    u_star[4] -= h
    u_star[5] += h
    nll_u23 = scaling.wilson_single_nll_aniso(ms.indices()[0], f_obs[0],
                                              sigma_f_obs[0], epsilon[0],
                                              sigma_sq[0], gamma[0],
                                              centric_array[0], p_scale,
                                              unit_cell, u_star)

    g = scaling.wilson_single_nll_aniso_gradient(ms.indices()[0], f_obs[0],
                                                 sigma_f_obs[0], epsilon[0],
                                                 sigma_sq[0], gamma[0],
                                                 centric_array[0], p_scale,
                                                 unit_cell, u_star)

    g2 = scaling.wilson_total_nll_aniso_gradient(ms.indices(), f_obs,
                                                 sigma_f_obs, epsilon,
                                                 sigma_sq, gamma,
                                                 centric_array, p_scale,
                                                 unit_cell, u_star)
    ds = (nll_norm - nll_scale) / -h
    du11 = (nll_norm - nll_u11) / -h
    du22 = (nll_norm - nll_u22) / -h
    du33 = (nll_norm - nll_u33) / -h
    du12 = (nll_norm - nll_u12) / -h
    du13 = (nll_norm - nll_u13) / -h
    du23 = (nll_norm - nll_u23) / -h
    assert approx_equal(ds, g[0]), (ds, g[0])
    assert approx_equal(du11, g[1]), (du11, g[1])
    assert approx_equal(du22, g[2])
    assert approx_equal(du33, g[3])
    assert approx_equal(du12, g[4])
    assert approx_equal(du13, g[5])
    assert approx_equal(du23, g[6])

    assert approx_equal(ds, g2[0] / 2.0)
    assert approx_equal(du11, g2[1] / 2.0)
    assert approx_equal(du22, g2[2] / 2.0)
    assert approx_equal(du33, g2[3] / 2.0)
    assert approx_equal(du12, g2[4] / 2.0)
    assert approx_equal(du13, g2[5] / 2.0)
    assert approx_equal(du23, g2[6] / 2.0)
Пример #4
0
def finite_diffs_aniso(p_scale,
                       u_star,
                       centric=False,
                       h=0.0001):
  d_star_sq = flex.double(2,0.25)
  f_obs =  flex.double(2,1.0)
  centric_array = flex.bool(2,centric)
  sigma_f_obs = f_obs/10.0
  sigma_sq = flex.double(2,1.0)
  epsilon = flex.double(2,1.0)
  gamma =flex.double(2,0.0)
  unit_cell = uctbx.unit_cell('20, 30, 40, 90.0, 90.0, 90.0')
  mi = flex.miller_index(((1,2,3), (1,2,3)))
  xs = crystal.symmetry((20,30,40), "P 2 2 2")
  ms = miller.set(xs, mi)

  nll_norm = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale,
                                             unit_cell,
                                             u_star)

  nll_scale = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale+h,
                                             unit_cell,
                                             u_star)
  u_star[0]+=h
  nll_u11 = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale,
                                             unit_cell,
                                             u_star)
  u_star[0]-=h
  u_star[1]+=h
  nll_u22 = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale,
                                             unit_cell,
                                             u_star)
  u_star[1]-=h
  u_star[2]+=h
  nll_u33 = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale,
                                             unit_cell,
                                             u_star)
  u_star[2]-=h
  u_star[3]+=h
  nll_u12 = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale,
                                             unit_cell,
                                             u_star)
  u_star[3]-=h
  u_star[4]+=h
  nll_u13 = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                             f_obs[0],
                                             sigma_f_obs[0],
                                             epsilon[0],
                                             sigma_sq[0],
                                             gamma[0],
                                             centric_array[0],
                                             p_scale,
                                             unit_cell,
                                             u_star)
  u_star[4]-=h
  u_star[5]+=h
  nll_u23 = scaling.wilson_single_nll_aniso(ms.indices()[0],
                                            f_obs[0],
                                            sigma_f_obs[0],
                                            epsilon[0],
                                            sigma_sq[0],
                                            gamma[0],
                                            centric_array[0],
                                            p_scale,
                                            unit_cell,
                                            u_star)


  g = scaling.wilson_single_nll_aniso_gradient(ms.indices()[0],
                                               f_obs[0],
                                               sigma_f_obs[0],
                                               epsilon[0],
                                               sigma_sq[0],
                                               gamma[0],
                                               centric_array[0],
                                               p_scale,
                                               unit_cell,
                                               u_star)

  g2 = scaling.wilson_total_nll_aniso_gradient(ms.indices(),
                                               f_obs,
                                               sigma_f_obs,
                                               epsilon,
                                               sigma_sq,
                                               gamma,
                                               centric_array,
                                               p_scale,
                                               unit_cell,
                                               u_star)
  ds=(nll_norm-nll_scale)/-h
  du11=(nll_norm-nll_u11)/-h
  du22=(nll_norm-nll_u22)/-h
  du33=(nll_norm-nll_u33)/-h
  du12=(nll_norm-nll_u12)/-h
  du13=(nll_norm-nll_u13)/-h
  du23=(nll_norm-nll_u23)/-h
  assert approx_equal(ds,g[0]), (ds,g[0])
  assert approx_equal(du11,g[1]), (du11,g[1])
  assert approx_equal(du22,g[2])
  assert approx_equal(du33,g[3])
  assert approx_equal(du12,g[4])
  assert approx_equal(du13,g[5])
  assert approx_equal(du23,g[6])

  assert approx_equal(ds,g2[0]/2.0)
  assert approx_equal(du11,g2[1]/2.0)
  assert approx_equal(du22,g2[2]/2.0)
  assert approx_equal(du33,g2[3]/2.0)
  assert approx_equal(du12,g2[4]/2.0)
  assert approx_equal(du13,g2[5]/2.0)
  assert approx_equal(du23,g2[6]/2.0)