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
Example #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
Example #3
0
def test_likelihood_aniso():
    u_star = [0, 0, 0, 0, 0, 0]
    d_star_sq = flex.double(2, 0.25)
    f_obs = flex.double(2, 1.0)
    centric_array = flex.bool(2, True)
    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_centric_aniso = 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], 0.0, unit_cell, u_star)

    assert approx_equal(nll_centric_aniso, 1.07239)  ## from Mathematica
    nll_acentric_aniso = 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], 0.0, unit_cell, u_star)
    centric_array = flex.bool(2, False)
    nll_acentric_aniso = 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], 0.0, unit_cell, u_star)
    assert approx_equal(nll_acentric_aniso, 0.306902)  ## from Mathematica

    centric_array = flex.bool(2, True)
    u_star = [1, 1, 1, 0, 0, 0]
    nll_centric_aniso = 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], 0.0, unit_cell, u_star)
    assert approx_equal(nll_centric_aniso, 1.535008)  ## from Mathematica
    centric_array = flex.bool(2, False)
    nll_acentric_aniso = 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], 0.0, unit_cell, u_star)
    assert approx_equal(nll_acentric_aniso, 0.900003)  ## from Mathematica

    centric_array[1] = True
    nll_total_aniso = scaling.wilson_total_nll_aniso(ms.indices(), f_obs,
                                                     sigma_f_obs, epsilon,
                                                     sigma_sq, gamma,
                                                     centric_array, 0.0,
                                                     unit_cell, u_star)
    assert approx_equal(nll_total_aniso, 2.435011)
Example #4
0
def test_likelihood_aniso():
  u_star = [0,0,0,0,0,0]
  d_star_sq = flex.double(2,0.25)
  f_obs =  flex.double(2,1.0)
  centric_array = flex.bool(2,True)
  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_centric_aniso = 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],
                                                      0.0,
                                                      unit_cell,
                                                      u_star)


  assert approx_equal(nll_centric_aniso,  1.07239 ) ## from Mathematica
  nll_acentric_aniso = 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],
                                                       0.0,
                                                       unit_cell,
                                                       u_star)
  centric_array = flex.bool(2,False)
  nll_acentric_aniso = 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],
                                                       0.0,
                                                       unit_cell,
                                                       u_star)
  assert approx_equal(nll_acentric_aniso,0.306902 ) ## from Mathematica

  centric_array = flex.bool(2,True)
  u_star = [1,1,1,0,0,0]
  nll_centric_aniso = 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],
                                                      0.0,
                                                      unit_cell,
                                                      u_star)
  assert approx_equal(nll_centric_aniso,  1.535008 ) ## from Mathematica
  centric_array = flex.bool(2,False)
  nll_acentric_aniso = 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],
                                                      0.0,
                                                      unit_cell,
                                                      u_star)
  assert approx_equal(nll_acentric_aniso,  0.900003 ) ## from Mathematica

  centric_array[1]=True
  nll_total_aniso = scaling.wilson_total_nll_aniso(ms.indices(),
                                                   f_obs,
                                                   sigma_f_obs,
                                                   epsilon,
                                                   sigma_sq,
                                                   gamma,
                                                   centric_array,
                                                   0.0,
                                                   unit_cell,
                                                   u_star)
  assert approx_equal(nll_total_aniso,  2.435011)