Exemple #1
0
def exercise_geometry():
    xs = quartz()
    uc = xs.unit_cell()
    flags = xs.scatterer_flags()
    for f in flags:
        f.set_grad_site(True)
    xs.set_scatterer_flags(flags)
    cov = flex.double(
        (1e-8, 1e-9, 2e-9, 3e-9, 4e-9, 5e-9, 2e-8, 1e-9, 2e-9, 3e-9, 4e-9,
         3e-8, 1e-9, 2e-9, 3e-9, 2e-8, 1e-9, 2e-9, 3e-8, 1e-9, 4e-8))
    cell_vcv = flex.double((3e-2, 3e-2, 0, 0, 0, 0, 3e-2, 0, 0, 0, 0, 4e-2, 0,
                            0, 0, 0, 0, 0, 0, 0, 0))
    param_map = xs.parameter_map()
    cov_cart = covariance.orthogonalize_covariance_matrix(cov, uc, param_map)
    O = matrix.sqr(uc.orthogonalization_matrix())
    F = matrix.sqr(uc.fractionalization_matrix())
    sites_cart = xs.sites_cart()
    sites_frac = xs.sites_frac()
    # distances
    rt_mx_ji = sgtbx.rt_mx('-y,x-y,z-1/3')
    sites = (sites_cart[0], uc.orthogonalize(rt_mx_ji * sites_frac[1]))
    d = geometry.distance(sites)
    assert approx_equal(d.distance_model, 1.6159860469110217)
    v = matrix.col(sites[1]) - matrix.col(sites[0])
    r_inv_cart = (O * matrix.sqr(rt_mx_ji.r().inverse().as_double()) * F)
    g = d.d_distance_d_sites()
    g = matrix.row(g[0] + tuple(r_inv_cart * matrix.col(g[1])))
    f = g * matrix.sqr(cov_cart.matrix_packed_u_as_symmetric()) * g.transpose()
    assert approx_equal(d.variance(cov_cart, uc, rt_mx_ji), f[0], eps=1e-15)
    assert approx_equal(0.0018054494791580823,
                        d.variance(cov_cart, cell_vcv, uc, rt_mx_ji))
    rt_mx_ji = sgtbx.rt_mx('x+1,y,z')
    sites = (sites_cart[0], uc.orthogonalize(rt_mx_ji * sites_frac[0]))
    d = geometry.distance(sites)
    assert approx_equal(d.distance_model, uc.parameters()[0])
    assert approx_equal(cell_vcv.matrix_packed_u_diagonal()[0],
                        d.variance(cov_cart, cell_vcv, uc, rt_mx_ji))
    # angles
    rt_mx_ji = sgtbx.rt_mx('x-y,x,z-2/3')
    rt_mx_ki = sgtbx.rt_mx('-y,x-y,z-1/3')
    r_inv_cart_ji = (O * matrix.sqr(rt_mx_ji.r().inverse().as_double()) * F)
    r_inv_cart_ki = (O * matrix.sqr(rt_mx_ki.r().inverse().as_double()) * F)
    cov_a = covariance.extract_covariance_matrix_for_sites(
        flex.size_t([1, 0, 1]), cov_cart, param_map)
    sites = (uc.orthogonalize(rt_mx_ji * sites_frac[1]), sites_cart[0],
             uc.orthogonalize(rt_mx_ki * sites_frac[1]))
    a = geometry.angle(sites)
    assert approx_equal(a.angle_model, 101.30738566828551)
    g = a.d_angle_d_sites()
    g = matrix.row(
        tuple(r_inv_cart_ji * matrix.col(g[0])) + g[1] +
        tuple(r_inv_cart_ki * matrix.col(g[2])))
    f = g * matrix.sqr(cov_a.matrix_packed_u_as_symmetric()) * g.transpose()
    assert approx_equal(a.variance(cov_a, uc,
                                   (rt_mx_ji, sgtbx.rt_mx(), rt_mx_ki)),
                        f[0],
                        eps=1e-15)
    assert approx_equal(
        0.0042632511984529199,
        a.variance(cov_a, cell_vcv, uc, (rt_mx_ji, sgtbx.rt_mx(), rt_mx_ki)))
Exemple #2
0
def is_coplanar(x,y,z):
  #triple product is zero; (X x Y).Z
  from scitbx import matrix
  x = matrix.row(x)
  y = matrix.row(y)
  z = matrix.row(z)
  return x.cross(y).dot(z)==0
Exemple #3
0
def is_coplanar(x, y, z):
    #triple product is zero; (X x Y).Z
    from scitbx import matrix
    x = matrix.row(x)
    y = matrix.row(y)
    z = matrix.row(z)
    return x.cross(y).dot(z) == 0
  def __init__(self,params):
    import cPickle as pickle
    from dxtbx.model.beam import beam_factory
    from dxtbx.model.detector import detector_factory
    from dxtbx.model.crystal import crystal_model
    from cctbx.crystal_orientation import crystal_orientation,basis_type
    from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList
    from scitbx import matrix
    self.experiments = ExperimentList()
    self.unique_file_names = []

    self.params = params
    data = pickle.load(open(self.params.output.prefix+"_frame.pickle","rb"))
    frames_text = data.split("\n")

    for item in frames_text:
      tokens = item.split(' ')
      wavelength = float(tokens[order_dict["wavelength"]])

      beam = beam_factory.simple(wavelength = wavelength)

      detector = detector_factory.simple(
        sensor = detector_factory.sensor("PAD"), # XXX shouldn't hard code for XFEL
        distance = float(tokens[order_dict["distance"]]),
        beam_centre = [float(tokens[order_dict["beam_x"]]), float(tokens[order_dict["beam_y"]])],
        fast_direction = "+x",
        slow_direction = "+y",
        pixel_size = [self.params.pixel_size,self.params.pixel_size],
        image_size = [1795,1795],  # XXX obviously need to figure this out
        )

      reciprocal_matrix = matrix.sqr([float(tokens[order_dict[k]]) for k in [
'res_ori_1','res_ori_2','res_ori_3','res_ori_4','res_ori_5','res_ori_6','res_ori_7','res_ori_8','res_ori_9']])
      ORI = crystal_orientation(reciprocal_matrix, basis_type.reciprocal)
      direct = matrix.sqr(ORI.direct_matrix())
      crystal = crystal_model(
        real_space_a = matrix.row(direct[0:3]),
        real_space_b = matrix.row(direct[3:6]),
        real_space_c = matrix.row(direct[6:9]),
        space_group_symbol = "P63",  # XXX obviously another gap in the database paradigm
        mosaicity = float(tokens[order_dict["half_mosaicity_deg"]]),
      )
      crystal.domain_size = float(tokens[order_dict["domain_size_ang"]])
      #if isoform is not None:
      #  newB = matrix.sqr(isoform.fractionalization_matrix()).transpose()
      #  crystal.set_B(newB)

      self.experiments.append(Experiment(beam=beam,
                                  detector=None, #dummy for now
                                  crystal=crystal))
      self.unique_file_names.append(tokens[order_dict["unique_file_name"]])

    self.show_summary()
def exercise(args):
  verbose =  "--verbose" in args
  if (not verbose):
    out = StringIO()
  else:
    out = sys.stdout
  for i_trial in xrange(10):
    for n_sites in xrange(2,5+1):
      ops = []
      for i in xrange(3):
        ops.append(matrix.sqr(flex.random_double(size=9, factor=2)-1))
      sites = []
      for i in xrange(n_sites):
        sites.append(matrix.col(flex.random_double(size=3, factor=4)-2))
      hkl = matrix.row(flex.random_double(size=3, factor=4)-2)
      sf = exp_i_hx(sites=sites, ops=ops, hkl=hkl)
      for obs_factor in [1, 1.1]:
        obs = abs(sf.f()) * obs_factor
        grads_fin = d_exp_i_hx_d_sites_finite(
          sites=sites, ops=ops, obs=obs, hkl=hkl)
        print >> out, "grads_fin:", list(grads_fin)
        tf = least_squares(obs=obs, calc=sf.f())
        grads_ana = sf.d_target_d_sites(target=tf)
        print >> out, "grads_ana:", list(grads_ana)
        compare_derivatives(grads_ana, grads_fin)
        curvs_fin = d2_exp_i_hx_d_sites_finite(
          sites=sites, ops=ops, obs=obs, hkl=hkl)
        print >> out, "curvs_fin:", list(curvs_fin)
        curvs_ana = sf.d2_target_d_sites(target=tf)
        print >> out, "curvs_ana:", list(curvs_ana)
        compare_derivatives(curvs_ana, curvs_fin)
        print >> out
  print "OK"
Exemple #6
0
def exercise(args):
    verbose = "--verbose" in args
    if (not verbose):
        out = StringIO()
    else:
        out = sys.stdout
    for i_trial in range(100):
        ops = []
        for i in range(3):
            ops.append(matrix.sqr(flex.random_double(size=9, factor=4) - 2))
        sites = []
        for i in range(2):
            sites.append(matrix.col(flex.random_double(size=3, factor=4) - 2))
        hkl = matrix.row(flex.random_double(size=3, factor=4) - 2)
        ca = cos_alpha(sites=sites, ops=ops, hkl=hkl)
        grads_fin = d_cos_alpha_d_sites_finite(sites=sites, ops=ops, hkl=hkl)
        print("grads_fin:", list(grads_fin), file=out)
        grads_ana = ca.d_sites()
        print("grads_ana:", list(grads_ana), file=out)
        assert approx_equal(grads_ana, grads_fin)
        curvs_fin = d2_cos_alpha_d_sites_finite(sites=sites, ops=ops, hkl=hkl)
        print("curvs_fin:", list(curvs_fin), file=out)
        curvs_ana = ca.d2_sites()
        print("curvs_ana:", list(curvs_ana), file=out)
        assert approx_equal(curvs_ana, curvs_fin, 1.e-5)
        print(file=out)
    print("OK")
def exercise(args):
    verbose = "--verbose" in args
    if (not verbose):
        out = StringIO()
    else:
        out = sys.stdout
    for i_trial in xrange(100):
        ops = []
        for i in xrange(3):
            ops.append(matrix.sqr(flex.random_double(size=9, factor=4) - 2))
        site = matrix.col(flex.random_double(size=3, factor=4) - 2)
        hkl = matrix.row(flex.random_double(size=3, factor=4) - 2)
        ca = cos_alpha(site=site, ops=ops, hkl=hkl)
        grads_fin = d_cos_alpha_d_site_finite(site=site, ops=ops, hkl=hkl)
        print >> out, "grads_fin:", list(grads_fin)
        grads_ana = ca.d_site()
        print >> out, "grads_ana:", list(grads_ana)
        assert approx_equal(grads_ana, grads_fin)
        curvs_fin = d2_cos_alpha_d_site_finite(site=site, ops=ops, hkl=hkl)
        print >> out, "curvs_fin:", list(curvs_fin)
        curvs_ana = ca.d2_site()
        print >> out, "curvs_ana:", list(curvs_ana)
        assert approx_equal(curvs_ana, curvs_fin)
        print >> out
    print "OK"
    def absence_detected(self, hkllist):
        self.hkl = hkllist
        self.N = self.hkl.size()
        self.flag = None

        from cctbx.sgtbx.sub_lattice_tools import generate_matrix
        allGenerators = []
        # include identity for on_means calculation
        for mod in [6, 5, 4, 3, 2]:
            for matS in generate_matrix(mod):
                allGenerators.append(matS)
        self.allGenerators = allGenerators

        for idx, matS in enumerate(allGenerators):
            invS = matS.inverse()

            idx_possible = True
            for miller in [matrix.row(i) for i in hkllist]:
                transformed_miller = miller * invS.transpose()
                #print transformed_miller
                for element in (transformed_miller).elems:
                    if element.denominator() > 1:
                        idx_possible = False

            #print "transformation",invS.transpose().elems,{True:"is",False:"not"}[idx_possible],"possible"
            if idx_possible:
                print "There are systematic absences. Applying transformation", invS.transpose(
                ).elems
                self.cb_op = invS.transpose().inverse(
                )  # not sure if transpose.inverse or just inverse
                self.flag = True
                return 1

        return 0
def exercise():
  ma = miller.array(
    miller.set(crystal.symmetry(unit_cell=(5,5,5, 90, 90, 90),
                                space_group=sgtbx.space_group('P 2x')),
               indices=flex.miller_index(
                 [(1,0,0), (0,1,0), (0,0,1),
                  (-1,0,0), (0,-1,0), (0,0,-1),
                  (1,1,0), (1,0,1), (0,1,1),
                  (-1,-1,0), (-1,0,-1), (0,-1,-1),
                  (1,-1,0), (1,0,-1), (0,1,-1),
                  (-1,1,0), (-1,0,1), (0,-1,1),
                  (1,1,1), (-1,1,1), (1,-1,1), (1,1,-1),
                  (-1,-1,-1), (1,-1,-1), (-1,1,-1), (-1,-1,1)])),
    data=flex.complex_double(flex.random_double(26), flex.random_double(26)))
  f_at_h = dict(zip(ma.indices(), ma.data()))
  for op in ("-x, y+1/2, -z", "x+1/2, -y, z-1/2"):
    op = sgtbx.rt_mx(op)
    original, transformed = ma.common_sets(
      ma.change_basis(sgtbx.change_of_basis_op(op.inverse())))
    for h, f in original:
      assert f == f_at_h[h]
    for h, op_f in transformed:
      assert approx_equal(
        op_f,
        f_at_h[h*op.r()]*exp(1j*2*pi*row(h).dot(col(op.t().as_double()))))
  def absence_detected(self,hkllist):
    self.hkl = hkllist
    self.N   = self.hkl.size()
    self.flag = None

    from cctbx.sgtbx.sub_lattice_tools import generate_matrix
    allGenerators=[]
    # include identity for on_means calculation
    for mod in [6,5,4,3,2]:
        for matS in generate_matrix(mod):
          allGenerators.append(matS)
    self.allGenerators = allGenerators

    for idx,matS in enumerate(allGenerators):
        invS = matS.inverse()

        idx_possible = True
        for miller in [matrix.row(i) for i in hkllist]:
          transformed_miller = miller*invS.transpose()
          #print transformed_miller
          for element in (transformed_miller).elems:
            if element.denominator() > 1:
              idx_possible = False

        #print "transformation",invS.transpose().elems,{True:"is",False:"not"}[idx_possible],"possible"
        if idx_possible:
          print "There are systematic absences. Applying transformation",invS.transpose().elems
          self.cb_op = invS.transpose().inverse()  # not sure if transpose.inverse or just inverse
          self.flag = True
          return 1

    return 0
def exercise(args):
  verbose =  "--verbose" in args
  if (not verbose):
    out = StringIO()
  else:
    out = sys.stdout
  for i_trial in xrange(100):
    ops = []
    for i in xrange(3):
      ops.append(matrix.sqr(flex.random_double(size=9, factor=4)-2))
    u = matrix.col((flex.random_double(size=6, factor=2)-1)*1.e-3)
    hkl = matrix.row(flex.random_double(size=3, factor=4)-2)
    dw = debye_waller(u=u, ops=ops, hkl=hkl)
    grads_fin = d_debye_waller_d_u_finite(u=u, ops=ops, hkl=hkl)
    print >> out, "grads_fin:", list(grads_fin)
    grads_ana = dw.d_u()
    print >> out, "grads_ana:", list(grads_ana)
    compare_derivatives(grads_ana, grads_fin)
    curvs_fin = d2_debye_waller_d_u_finite(u=u, ops=ops, hkl=hkl)
    print >> out, "curvs_fin:", list(curvs_fin)
    curvs_ana = dw.d2_u()
    print >> out, "curvs_ana:", list(curvs_ana)
    compare_derivatives(curvs_ana, curvs_fin)
    print >> out
  print "OK"
def exercise(args):
    verbose = "--verbose" in args
    if (not verbose):
        out = StringIO()
    else:
        out = sys.stdout
    for i_trial in range(100):
        ops = []
        for i in range(3):
            ops.append(matrix.sqr(flex.random_double(size=9, factor=4) - 2))
        u = matrix.col((flex.random_double(size=6, factor=2) - 1) * 1.e-3)
        hkl = matrix.row(flex.random_double(size=3, factor=4) - 2)
        dw = debye_waller(u=u, ops=ops, hkl=hkl)
        grads_fin = d_debye_waller_d_u_finite(u=u, ops=ops, hkl=hkl)
        print("grads_fin:", list(grads_fin), file=out)
        grads_ana = dw.d_u()
        print("grads_ana:", list(grads_ana), file=out)
        compare_derivatives(grads_ana, grads_fin)
        curvs_fin = d2_debye_waller_d_u_finite(u=u, ops=ops, hkl=hkl)
        print("curvs_fin:", list(curvs_fin), file=out)
        curvs_ana = dw.d2_u()
        print("curvs_ana:", list(curvs_ana), file=out)
        compare_derivatives(curvs_ana, curvs_fin)
        print(file=out)
    print("OK")
def exercise(args):
  verbose =  "--verbose" in args
  if (not verbose):
    out = StringIO()
  else:
    out = sys.stdout
  for i_trial in range(10):
    for n_sites in range(2,5+1):
      ops = []
      for i in range(3):
        ops.append(matrix.sqr(flex.random_double(size=9, factor=2)-1))
      sites = []
      for i in range(n_sites):
        sites.append(matrix.col(flex.random_double(size=3, factor=4)-2))
      hkl = matrix.row(flex.random_double(size=3, factor=4)-2)
      sf = exp_i_hx(sites=sites, ops=ops, hkl=hkl)
      for obs_factor in [1, 1.1]:
        obs = abs(sf.f()) * obs_factor
        grads_fin = d_exp_i_hx_d_sites_finite(
          sites=sites, ops=ops, obs=obs, hkl=hkl)
        print("grads_fin:", list(grads_fin), file=out)
        tf = least_squares(obs=obs, calc=sf.f())
        grads_ana = sf.d_target_d_sites(target=tf)
        print("grads_ana:", list(grads_ana), file=out)
        compare_derivatives(grads_ana, grads_fin)
        curvs_fin = d2_exp_i_hx_d_sites_finite(
          sites=sites, ops=ops, obs=obs, hkl=hkl)
        print("curvs_fin:", list(curvs_fin), file=out)
        curvs_ana = sf.d2_target_d_sites(target=tf)
        print("curvs_ana:", list(curvs_ana), file=out)
        compare_derivatives(curvs_ana, curvs_fin)
        print(file=out)
  print("OK")
 def f(self):
   result = 0
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   for scatterer in self.scatterers:
     w = scatterer.weight()
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     gaussian = self.scattering_type_registry.gaussian_not_optional(
       scattering_type=scatterer.scattering_type)
     f0 = gaussian.at_d_star_sq(self.d_star_sq)
     ffp = f0 + scatterer.fp
     fdp = scatterer.fdp
     ff = ffp + 1j * fdp
     for s in self.space_group:
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         r = s.r().as_rational().as_float()
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       result += w * dw * ff * e
   return result
 def __init__(self, h, site_constraints, independent_params):
     self.h = matrix.row(h)
     self.site_constraints = site_constraints
     self.independent_params = independent_params
     self.site = matrix.col(
         self.site_constraints.all_params(
             independent_params=self.independent_params))
def exercise():
    ma = miller.array(miller.set(
        crystal.symmetry(unit_cell=(5, 5, 5, 90, 90, 90),
                         space_group=sgtbx.space_group('P 2x')),
        indices=flex.miller_index([(1, 0, 0), (0, 1, 0), (0, 0, 1), (-1, 0, 0),
                                   (0, -1, 0), (0, 0, -1), (1, 1, 0),
                                   (1, 0, 1), (0, 1, 1), (-1, -1, 0),
                                   (-1, 0, -1), (0, -1, -1), (1, -1, 0),
                                   (1, 0, -1), (0, 1, -1), (-1, 1, 0),
                                   (-1, 0, 1), (0, -1, 1), (1, 1, 1),
                                   (-1, 1, 1), (1, -1, 1), (1, 1, -1),
                                   (-1, -1, -1), (1, -1, -1), (-1, 1, -1),
                                   (-1, -1, 1)])),
                      data=flex.complex_double(flex.random_double(26),
                                               flex.random_double(26)))
    f_at_h = dict(zip(ma.indices(), ma.data()))
    for op in ("-x, y+1/2, -z", "x+1/2, -y, z-1/2"):
        op = sgtbx.rt_mx(op)
        original, transformed = ma.common_sets(
            ma.change_basis(sgtbx.change_of_basis_op(op.inverse())))
        for h, f in original:
            assert f == f_at_h[h]
        for h, op_f in transformed:
            assert approx_equal(
                op_f, f_at_h[h * op.r()] *
                exp(1j * 2 * pi * row(h).dot(col(op.t().as_double()))))
def exercise(args):
    verbose = "--verbose" in args
    if not verbose:
        out = StringIO()
    else:
        out = sys.stdout
    for i_trial in xrange(100):
        ops = []
        for i in xrange(3):
            ops.append(matrix.sqr(flex.random_double(size=9, factor=4) - 2))
        sites = []
        for i in xrange(2):
            sites.append(matrix.col(flex.random_double(size=3, factor=4) - 2))
        hkl = matrix.row(flex.random_double(size=3, factor=4) - 2)
        ca = cos_alpha(sites=sites, ops=ops, hkl=hkl)
        grads_fin = d_cos_alpha_d_sites_finite(sites=sites, ops=ops, hkl=hkl)
        print >> out, "grads_fin:", list(grads_fin)
        grads_ana = ca.d_sites()
        print >> out, "grads_ana:", list(grads_ana)
        assert approx_equal(grads_ana, grads_fin)
        curvs_fin = d2_cos_alpha_d_sites_finite(sites=sites, ops=ops, hkl=hkl)
        print >> out, "curvs_fin:", list(curvs_fin)
        curvs_ana = ca.d2_sites()
        print >> out, "curvs_ana:", list(curvs_ana)
        assert approx_equal(curvs_ana, curvs_fin, 1.0e-5)
        print >> out
    print "OK"
Exemple #18
0
 def f(self):
     result = 0
     tphkl = 2 * math.pi * matrix.col(self.hkl)
     for scatterer in self.scatterers:
         w = scatterer.weight()
         if (not scatterer.flags.use_u_aniso()):
             huh = scatterer.u_iso * self.d_star_sq
             dw = math.exp(mtps * huh)
         gaussian = self.scattering_type_registry.gaussian_not_optional(
             scattering_type=scatterer.scattering_type)
         f0 = gaussian.at_d_star_sq(self.d_star_sq)
         ffp = f0 + scatterer.fp
         fdp = scatterer.fdp
         ff = ffp + 1j * fdp
         for s in self.space_group:
             s_site = s * scatterer.site
             alpha = matrix.col(s_site).dot(tphkl)
             if (scatterer.flags.use_u_aniso()):
                 r = s.r().as_rational().as_float()
                 s_u_star_s = r * matrix.sym(
                     sym_mat3=scatterer.u_star) * r.transpose()
                 huh = (matrix.row(self.hkl) * s_u_star_s).dot(
                     matrix.col(self.hkl))
                 dw = math.exp(mtps * huh)
             e = cmath.exp(1j * alpha)
             result += w * dw * ff * e
     return result
 def f(self):
   result = 0
   for op in self.ops:
     op_u = (op*matrix.sym(sym_mat3=self.u)*op.transpose()).as_sym_mat3()
     huh = (matrix.row(self.hkl) \
         * matrix.sym(sym_mat3=op_u)).dot(matrix.col(self.hkl))
     result += math.exp(mtps * huh)
   return result
Exemple #20
0
    def __init__(self,
                 crystal_symmetry,
                 cell_covariance_matrix=None,
                 format="coreCIF"):
        self.format = format.lower()
        assert self.format in ("corecif", "mmcif")
        if self.format == "mmcif": self.separator = '.'
        else: self.separator = '_'
        self.cif_block = model.block()
        cell_prefix = '_cell%s' % self.separator
        if crystal_symmetry.space_group() is not None:
            sym_loop = model.loop(data=OrderedDict((
                ('_space_group_symop' + self.separator + 'id',
                 range(1,
                       len(crystal_symmetry.space_group()) + 1)),
                ('_space_group_symop' + self.separator + 'operation_xyz',
                 [s.as_xyz() for s in crystal_symmetry.space_group()]))))
            self.cif_block.add_loop(sym_loop)
            sg_prefix = '_space_group%s' % self.separator
            sg_type = crystal_symmetry.space_group_info().type()
            sg = sg_type.group()
            self.cif_block[sg_prefix +
                           'crystal_system'] = sg.crystal_system().lower()
            self.cif_block[sg_prefix + 'IT_number'] = sg_type.number()
            self.cif_block[sg_prefix +
                           'name_H-M_alt'] = sg_type.lookup_symbol()
            self.cif_block[sg_prefix + 'name_Hall'] = sg_type.hall_symbol()

            sg_prefix = '_symmetry%s' % self.separator
            self.cif_block[sg_prefix +
                           'space_group_name_H-M'] = sg_type.lookup_symbol()
            self.cif_block[sg_prefix +
                           'space_group_name_Hall'] = sg_type.hall_symbol()
            self.cif_block[sg_prefix + 'Int_Tables_number'] = sg_type.number()

        if crystal_symmetry.unit_cell() is not None:
            uc = crystal_symmetry.unit_cell()
            params = list(uc.parameters())
            volume = uc.volume()
            if cell_covariance_matrix is not None:
                diag = cell_covariance_matrix.matrix_packed_u_diagonal()
                for i in range(6):
                    if diag[i] > 0:
                        params[i] = format_float_with_su(
                            params[i], math.sqrt(diag[i]))
                d_v_d_params = matrix.row(uc.d_volume_d_params())
                vcv = matrix.sqr(
                    cell_covariance_matrix.matrix_packed_u_as_symmetric())
                var_v = (d_v_d_params * vcv).dot(d_v_d_params)
                volume = format_float_with_su(volume, math.sqrt(var_v))
            a, b, c, alpha, beta, gamma = params
            self.cif_block[cell_prefix + 'length_a'] = a
            self.cif_block[cell_prefix + 'length_b'] = b
            self.cif_block[cell_prefix + 'length_c'] = c
            self.cif_block[cell_prefix + 'angle_alpha'] = alpha
            self.cif_block[cell_prefix + 'angle_beta'] = beta
            self.cif_block[cell_prefix + 'angle_gamma'] = gamma
            self.cif_block[cell_prefix + 'volume'] = volume
 def f(self):
     result = 0
     for op in self.ops:
         op_u = (op * matrix.sym(sym_mat3=self.u) *
                 op.transpose()).as_sym_mat3()
         huh = (matrix.row(self.hkl) \
             * matrix.sym(sym_mat3=op_u)).dot(matrix.col(self.hkl))
         result += math.exp(mtps * huh)
     return result
Exemple #22
0
def test_direction():
    from cctbx.array_family import flex
    from cctbx import uctbx, xray, crystal
    from smtbx.refinement import constraints
    from scitbx.matrix import col, row
    from libtbx.test_utils import approx_equal

    uc = uctbx.unit_cell((1, 2, 3))
    xs = xray.structure(crystal_symmetry=crystal.symmetry(
        unit_cell=uc, space_group_symbol='hall: P 2x 2y'),
                        scatterers=flex.xray_scatterer((
                            xray.scatterer('C0', site=(0, 0, 0)),
                            xray.scatterer('C1', site=(0, 2, 0)),
                            xray.scatterer('C2', site=(1, 1, 0)),
                            xray.scatterer('C3', site=(3, 1, 0)),
                        )))
    r = constraints.ext.reparametrisation(xs.unit_cell())
    sc = xs.scatterers()
    site_0 = r.add(constraints.independent_site_parameter, sc[0])
    site_1 = r.add(constraints.independent_site_parameter, sc[1])
    site_2 = r.add(constraints.independent_site_parameter, sc[2])
    site_3 = r.add(constraints.independent_site_parameter, sc[3])
    d = constraints.vector_direction((site_0, site_1, site_2)).direction(uc)
    sd = constraints.static_direction.calc_best_line(uc,
                                                     (site_0, site_1, site_2))
    assert approx_equal(d, sd, eps=1e-15)

    d = constraints.vector_direction((site_0, site_1)).direction(uc)
    assert approx_equal(
        d,
        row(uc.orthogonalize(col(sc[1].site) - col(sc[0].site))).normalize(),
        eps=1e-15)

    n = constraints.static_direction.calc_best_plane_normal(
        uc, (site_0, site_1, site_2))

    n1 = constraints.static_direction.calc_best_plane_normal(
        uc, (site_0, site_1, site_2, site_3))

    v01 = uc.orthogonalize(col(sc[0].site) - col(sc[1].site))
    v21 = uc.orthogonalize(col(sc[2].site) - col(sc[1].site))
    nc = row(v01).cross(row(v21)).normalize()
    assert approx_equal(n, n1, eps=1e-15)
    assert approx_equal(n, nc, eps=1e-15)
    def prepare_dxtbx_models(self, setting_specific_ai, sg, isoform=None):

        from dxtbx.model import BeamFactory
        beam = BeamFactory.simple(wavelength=self.inputai.wavelength)

        from dxtbx.model import DetectorFactory
        detector = DetectorFactory.simple(
            sensor=DetectorFactory.sensor("PAD"),
            distance=setting_specific_ai.distance(),
            beam_centre=[
                setting_specific_ai.xbeam(),
                setting_specific_ai.ybeam()
            ],
            fast_direction="+x",
            slow_direction="+y",
            pixel_size=[self.pixel_size, self.pixel_size],
            image_size=[self.inputpd['size1'], self.inputpd['size1']],
        )

        direct = matrix.sqr(
            setting_specific_ai.getOrientation().direct_matrix())
        from dxtbx.model import Crystal
        crystal = Crystal(
            real_space_a=matrix.row(direct[0:3]),
            real_space_b=matrix.row(direct[3:6]),
            real_space_c=matrix.row(direct[6:9]),
            space_group_symbol=sg,
        )
        crystal.set_mosaicity(setting_specific_ai.getMosaicity())
        if isoform is not None:
            newB = matrix.sqr(isoform.fractionalization_matrix()).transpose()
            crystal.set_B(newB)

        from dxtbx.model import Experiment, ExperimentList
        experiments = ExperimentList()
        experiments.append(
            Experiment(beam=beam, detector=detector, crystal=crystal))

        print beam
        print detector
        print crystal
        return experiments
Exemple #24
0
 def _gradient_map_coeff(self):
     coeff = self.miller_set().array(
         data=self.d_target_d_f_calc().deep_copy())
     multiplier = (self.manager().unit_cell().volume() /
                   matrix.row(self.manager().rfft().n_real()).product() *
                   self.manager().space_group().n_ltr())
     if (not coeff.anomalous_flag()
             and not coeff.space_group().is_centric()):
         multiplier /= 2
     ext.apply_u_extra(self.manager().unit_cell(), self._results.u_extra(),
                       coeff.indices(), coeff.data(), multiplier)
     return coeff
 def df_d_params(self):
   result = []
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   h,k,l = self.hkl
   d_exp_huh_d_u_star = matrix.col([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   for scatterer in self.scatterers:
     assert scatterer.scattering_type == "const"
     w = scatterer.occupancy
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     ffp = 1 + scatterer.fp
     fdp = scatterer.fdp
     ff = ffp + 1j * fdp
     d_site = matrix.col([0,0,0])
     if (not scatterer.flags.use_u_aniso()):
       d_u_iso = 0
       d_u_star = None
     else:
       d_u_iso = None
       d_u_star = matrix.col([0,0,0,0,0,0])
     d_occ = 0
     d_fp = 0
     d_fdp = 0
     for s in self.space_group:
       r = s.r().as_rational().as_float()
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       site_gtmx = r.transpose()
       d_site += site_gtmx * (
         w * dw * ff * e * 1j * tphkl)
       if (not scatterer.flags.use_u_aniso()):
         d_u_iso += w * dw * ff * e * mtps * self.d_star_sq
       else:
         u_star_gtmx = matrix.sqr(tensor_rank_2_gradient_transform_matrix(r))
         d_u_star += u_star_gtmx * (
           w * dw * ff * e * mtps * d_exp_huh_d_u_star)
       d_occ += dw * ff * e
       d_fp += w * dw * e
       d_fdp += w * dw * e * 1j
     result.append(gradients(
       site=d_site,
       u_iso=d_u_iso,
       u_star=d_u_star,
       occupancy=d_occ,
       fp=d_fp,
       fdp=d_fdp))
   return result
Exemple #26
0
 def ft_dp(self, dp, u_extra):
     multiplier = (self.unit_cell().volume() /
                   matrix.row(self.rfft().n_real()).product() *
                   self.space_group().order_z() /
                   dp.multiplicities().data().as_double())
     coeff = dp.deep_copy()
     xray.apply_u_extra(self.unit_cell(), u_extra, coeff.indices(),
                        coeff.data())
     coeff_data = coeff.data()
     coeff_data *= flex.polar(multiplier, 0)
     return miller.fft_map(crystal_gridding=self.crystal_gridding(),
                           fourier_coefficients=coeff)
 def df_d_params(self):
   result = []
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   h,k,l = self.hkl
   d_exp_huh_d_u_star = matrix.col([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   for scatterer in self.scatterers:
     assert scatterer.scattering_type == "const"
     w = scatterer.occupancy
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     ffp = 1 + scatterer.fp
     fdp = scatterer.fdp
     ff = ffp + 1j * fdp
     d_site = matrix.col([0,0,0])
     if (not scatterer.flags.use_u_aniso()):
       d_u_iso = 0
       d_u_star = None
     else:
       d_u_iso = None
       d_u_star = matrix.col([0,0,0,0,0,0])
     d_occ = 0
     d_fp = 0
     d_fdp = 0
     for s in self.space_group:
       r = s.r().as_rational().as_float()
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       site_gtmx = r.transpose()
       d_site += site_gtmx * (
         w * dw * ff * e * 1j * tphkl)
       if (not scatterer.flags.use_u_aniso()):
         d_u_iso += w * dw * ff * e * mtps * self.d_star_sq
       else:
         u_star_gtmx = matrix.sqr(tensor_rank_2_gradient_transform_matrix(r))
         d_u_star += u_star_gtmx * (
           w * dw * ff * e * mtps * d_exp_huh_d_u_star)
       d_occ += dw * ff * e
       d_fp += w * dw * e
       d_fdp += w * dw * e * 1j
     result.append(gradients(
       site=d_site,
       u_iso=d_u_iso,
       u_star=d_u_star,
       occupancy=d_occ,
       fp=d_fp,
       fdp=d_fdp))
   return result
 def d_u(self):
   result = flex.double(6, 0)
   h,k,l = self.hkl
   d_exp_huh_d_u = matrix.col([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   for op in self.ops:
     op_u = (op*matrix.sym(sym_mat3=self.u)*op.transpose()).as_sym_mat3()
     huh = (matrix.row(self.hkl) \
         * matrix.sym(sym_mat3=op_u)).dot(matrix.col(self.hkl))
     d_op_u = math.exp(mtps * huh) * mtps * d_exp_huh_d_u
     gtmx = tensor_rank_2_gradient_transform_matrix(op)
     d_u = gtmx.matrix_multiply(flex.double(d_op_u))
     result += d_u
   return result
Exemple #29
0
 def __init__(self, reduced_cell, rot_mx, deg=False):
   orth = matrix.sqr(reduced_cell.orthogonalization_matrix())
   frac = matrix.sqr(reduced_cell.fractionalization_matrix())
   r_info = rot_mx.info()
   self.type = r_info.type()
   self.u = rot_mx.info().ev()
   self.h = rot_mx.transpose().info().ev()
   self.t = orth * matrix.col(self.u)
   self.tau = matrix.row(self.h) * frac
   if (abs(self.type) == 1):
     self.delta = 0.0
   else:
     self.delta = self.t.accute_angle(self.tau, deg=deg)
Exemple #30
0
 def __init__(self, reduced_cell, rot_mx, deg=False):
     orth = matrix.sqr(reduced_cell.orthogonalization_matrix())
     frac = matrix.sqr(reduced_cell.fractionalization_matrix())
     r_info = rot_mx.info()
     self.type = r_info.type()
     self.u = rot_mx.info().ev()
     self.h = rot_mx.transpose().info().ev()
     self.t = orth * matrix.col(self.u)
     self.tau = matrix.row(self.h) * frac
     if (abs(self.type) == 1):
         self.delta = 0.0
     else:
         self.delta = self.t.accute_angle(self.tau, deg=deg)
  def prepare_dxtbx_models(self,setting_specific_ai,sg,isoform=None):

    from dxtbx.model.beam import beam_factory
    beam = beam_factory.simple(wavelength = self.inputai.wavelength)

    from dxtbx.model.detector import detector_factory
    detector = detector_factory.simple(
      sensor = detector_factory.sensor("PAD"),
      distance = setting_specific_ai.distance(),
      beam_centre = [setting_specific_ai.xbeam(), setting_specific_ai.ybeam()],
      fast_direction = "+x",
      slow_direction = "+y",
      pixel_size = [self.pixel_size,self.pixel_size],
      image_size = [self.inputpd['size1'],self.inputpd['size1']],
      )

    direct = matrix.sqr(setting_specific_ai.getOrientation().direct_matrix())
    from dxtbx.model.crystal import crystal_model
    crystal = crystal_model(
      real_space_a = matrix.row(direct[0:3]),
      real_space_b = matrix.row(direct[3:6]),
      real_space_c = matrix.row(direct[6:9]),
      space_group_symbol = sg,
      mosaicity = setting_specific_ai.getMosaicity()
    )
    if isoform is not None:
      newB = matrix.sqr(isoform.fractionalization_matrix()).transpose()
      crystal.set_B(newB)

    from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList
    experiments = ExperimentList()
    experiments.append(Experiment(beam=beam,
                                  detector=detector,
                                  crystal=crystal))

    print beam
    print detector
    print crystal
    return experiments
Exemple #32
0
 def exercise_rotation(self):
   self.reset_sites()
   r = constraints.ext.reparametrisation(self.uc)
   sc = self.xs.scatterers()
   pivot = r.add(constraints.independent_site_parameter, sc[0])
   size = r.add(constraints.independent_scalar_parameter,
                   value=1, variable=False)
   r_x = r.add(constraints.independent_scalar_parameter,
                   value=pi, variable=True)
   r_y = r.add(constraints.independent_scalar_parameter,
                   value=pi/2, variable=True)
   r_z = r.add(constraints.independent_scalar_parameter,
                   value=pi/3, variable=True)
   rg = r.add(constraints.rigid_rotatable_expandable_group,
                 pivot=pivot,
                 size = size,
                 alpha = r_x,
                 beta = r_y,
                 gamma = r_z,
                 scatterers=(sc[1], sc[2], sc[3]))
   r.finalise()
   r.linearise()
   r.store()
   rx_m = mat.sqr((1, 0, 0,
               0, math.cos(self.rx), -math.sin(self.rx),
               0, math.sin(self.rx), math.cos(self.rx)))
   ry_m = mat.sqr((math.cos(self.ry), 0, math.sin(self.ry),
                   0, 1, 0,
                   -math.sin(self.ry), 0, math.cos(self.ry)))
   rz_m = mat.sqr((math.cos(self.rz), -math.sin(self.rz), 0,
                   math.sin(self.rz), math.cos(self.rz), 0,
                   0, 0, 1))
   R = rx_m*ry_m*rz_m #comulative rotation matrix
   shift = col(self.sites[0])-col(mat.row(col(self.sites[0])-self.center)*R)
   for i in xrange(1,4):
     calc_site = col(mat.row(col(self.sites[i])-self.center)*R) + shift
     assert approx_equal(
       self.uc.distance(
         calc_site, col(sc[i].site)), 0, eps=1e-14)
def exercise_direction():
  uc = uctbx.unit_cell((1, 2, 3))
  xs = xray.structure(
    crystal_symmetry=crystal.symmetry(
      unit_cell=uc,
      space_group_symbol='hall: P 2x 2y'),
    scatterers=flex.xray_scatterer((
      xray.scatterer('C0', site=(0,0,0)),
      xray.scatterer('C1', site=(0,2,0)),
      xray.scatterer('C2', site=(1,1,0)),
      xray.scatterer('C3', site=(3,1,0)),
      )))
  r = constraints.ext.reparametrisation(xs.unit_cell())
  sc = xs.scatterers()
  site_0 = r.add(constraints.independent_site_parameter, sc[0])
  site_1 = r.add(constraints.independent_site_parameter, sc[1])
  site_2 = r.add(constraints.independent_site_parameter, sc[2])
  site_3 = r.add(constraints.independent_site_parameter, sc[3])
  d = constraints.vector_direction((site_0, site_1, site_2)).direction(uc)
  sd = constraints.static_direction.calc_best_line(uc, (site_0, site_1, site_2))
  assert approx_equal(d, sd, eps=1e-15)

  d = constraints.vector_direction((site_0, site_1)).direction(uc)
  assert approx_equal(d,
    row(uc.orthogonalize(col(sc[1].site)-col(sc[0].site))).normalize(),
    eps=1e-15)

  n = constraints.static_direction.calc_best_plane_normal(
    uc, (site_0, site_1, site_2))

  n1 = constraints.static_direction.calc_best_plane_normal(
    uc, (site_0, site_1, site_2, site_3))

  v01 = uc.orthogonalize(col(sc[0].site)-col(sc[1].site))
  v21 = uc.orthogonalize(col(sc[2].site)-col(sc[1].site))
  nc = row(v01).cross(row(v21)).normalize()
  assert approx_equal(n, n1, eps=1e-15)
  assert approx_equal(n, nc, eps=1e-15)
 def d2_u(self):
   result = flex.double(flex.grid(6,6), 0)
   h,k,l = self.hkl
   d_exp_huh_d_u = flex.double([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   d2_exp_huh_d_uu = d_exp_huh_d_u.matrix_outer_product(d_exp_huh_d_u)
   for op in self.ops:
     op_u = (op*matrix.sym(sym_mat3=self.u)*op.transpose()).as_sym_mat3()
     huh = (matrix.row(self.hkl) \
         * matrix.sym(sym_mat3=op_u)).dot(matrix.col(self.hkl))
     d2_op_u = math.exp(mtps * huh) * mtps**2 * d2_exp_huh_d_uu
     gtmx = tensor_rank_2_gradient_transform_matrix(op)
     d2_u = gtmx.matrix_multiply(d2_op_u).matrix_multiply(
       gtmx.matrix_transpose())
     result += d2_u
   return result
 def _gradient_map_coeff(self):
   coeff = self.miller_set().array(data=self.d_target_d_f_calc().deep_copy())
   multiplier = (  self.manager().unit_cell().volume()
                 / matrix.row(self.manager().rfft().n_real()).product()
                 * self.manager().space_group().n_ltr())
   if (    not coeff.anomalous_flag()
       and not coeff.space_group().is_centric()):
     multiplier /= 2
   ext.apply_u_extra(
     self.manager().unit_cell(),
     self._results.u_extra(),
     coeff.indices(),
     coeff.data(),
     multiplier)
   return coeff
 def d_u(self):
     result = flex.double(6, 0)
     h, k, l = self.hkl
     d_exp_huh_d_u = matrix.col(
         [h**2, k**2, l**2, 2 * h * k, 2 * h * l, 2 * k * l])
     for op in self.ops:
         op_u = (op * matrix.sym(sym_mat3=self.u) *
                 op.transpose()).as_sym_mat3()
         huh = (matrix.row(self.hkl) \
             * matrix.sym(sym_mat3=op_u)).dot(matrix.col(self.hkl))
         d_op_u = math.exp(mtps * huh) * mtps * d_exp_huh_d_u
         gtmx = tensor_rank_2_gradient_transform_matrix(op)
         d_u = gtmx.matrix_multiply(flex.double(d_op_u))
         result += d_u
     return result
 def ft_dp(self, dp, u_extra):
   multiplier = (  self.unit_cell().volume()
                 / matrix.row(self.rfft().n_real()).product()
                 * self.space_group().order_z()
                 / dp.multiplicities().data().as_double())
   coeff = dp.deep_copy()
   xray.apply_u_extra(
     self.unit_cell(),
     u_extra,
     coeff.indices(),
     coeff.data())
   coeff_data = coeff.data()
   coeff_data *= flex.polar(multiplier, 0)
   return miller.fft_map(
     crystal_gridding=self.crystal_gridding(),
     fourier_coefficients=coeff)
 def d2_u(self):
     result = flex.double(flex.grid(6, 6), 0)
     h, k, l = self.hkl
     d_exp_huh_d_u = flex.double(
         [h**2, k**2, l**2, 2 * h * k, 2 * h * l, 2 * k * l])
     d2_exp_huh_d_uu = d_exp_huh_d_u.matrix_outer_product(d_exp_huh_d_u)
     for op in self.ops:
         op_u = (op * matrix.sym(sym_mat3=self.u) *
                 op.transpose()).as_sym_mat3()
         huh = (matrix.row(self.hkl) \
             * matrix.sym(sym_mat3=op_u)).dot(matrix.col(self.hkl))
         d2_op_u = math.exp(mtps * huh) * mtps**2 * d2_exp_huh_d_uu
         gtmx = tensor_rank_2_gradient_transform_matrix(op)
         d2_u = gtmx.matrix_multiply(d2_op_u).matrix_multiply(
             gtmx.matrix_transpose())
         result += d2_u
     return result
Exemple #39
0
 def __init__(self,
       points,
       epsilon=None,
       radius_if_one_or_no_points=1,
       center_if_no_points=(0,0,0)):
   assert len(points) > 0 or radius_if_one_or_no_points >= 0
   if (epsilon is None): epsilon = 1.e-6
   self._n_iterations = 0
   if (len(points) == 0):
     self._center = center_if_no_points
     self._radius = radius_if_one_or_no_points
     return
   if (len(points) == 1):
     self._center = tuple(points[0])
     self._radius = radius_if_one_or_no_points
     return
   n_dim = len(points[0].elems)
   w = 1./len(points)
   weights = matrix.row([w for i in xrange(len(points))])
   while 1:
     x = matrix.col([0]*n_dim)
     for w,t in zip(weights.elems,points):
       x += w * t
     radii = matrix.col([abs(x-t) for t in points])
     sigma = 0
     for w,r in zip(weights.elems,radii.elems):
       sigma += w * r**2
     sigma = math.sqrt(sigma)
     tau = radii.max()
     if (tau - sigma < tau * epsilon):
       break
     w_r = []
     for w,r in zip(weights.elems,radii.elems):
       w_r.append(w * r)
     w_r = matrix.col(w_r)
     sum_w_r = w_r.sum()
     assert sum_w_r != 0
     weights = w_r / sum_w_r
     self._n_iterations += 1
   self._center = x.elems
   self._radius = tau
Exemple #40
0
 def __init__(self,
              points,
              epsilon=None,
              radius_if_one_or_no_points=1,
              center_if_no_points=(0, 0, 0)):
     assert len(points) > 0 or radius_if_one_or_no_points >= 0
     if (epsilon is None): epsilon = 1.e-6
     self._n_iterations = 0
     if (len(points) == 0):
         self._center = center_if_no_points
         self._radius = radius_if_one_or_no_points
         return
     if (len(points) == 1):
         self._center = tuple(points[0])
         self._radius = radius_if_one_or_no_points
         return
     n_dim = len(points[0].elems)
     w = 1. / len(points)
     weights = matrix.row([w for i in xrange(len(points))])
     while 1:
         x = matrix.col([0] * n_dim)
         for w, t in zip(weights.elems, points):
             x += w * t
         radii = matrix.col([abs(x - t) for t in points])
         sigma = 0
         for w, r in zip(weights.elems, radii.elems):
             sigma += w * r**2
         sigma = math.sqrt(sigma)
         tau = radii.max()
         if (tau - sigma < tau * epsilon):
             break
         w_r = []
         for w, r in zip(weights.elems, radii.elems):
             w_r.append(w * r)
         w_r = matrix.col(w_r)
         sum_w_r = w_r.sum()
         assert sum_w_r != 0
         weights = w_r / sum_w_r
         self._n_iterations += 1
     self._center = x.elems
     self._radius = tau
 def f(self):
   result = 0
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   for scatterer in self.scatterers:
     assert scatterer.scattering_type == "const"
     w = scatterer.occupancy
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     ffp = 1 + scatterer.fp
     fdp = scatterer.fdp
     ff = ffp + 1j * fdp
     for s in self.space_group:
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         r = s.r().as_rational().as_float()
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       result += w * dw * ff * e
   return result
 def f(self):
   result = 0
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   for scatterer in self.scatterers:
     assert scatterer.scattering_type == "const"
     w = scatterer.occupancy
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     ffp = 1 + scatterer.fp
     fdp = scatterer.fdp
     ff = ffp + 1j * fdp
     for s in self.space_group:
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         r = s.r().as_rational().as_float()
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       result += w * dw * ff * e
   return result
Exemple #43
0
 def df_d_params(self):
     tphkl = 2 * math.pi * matrix.col(self.hkl)
     h, k, l = self.hkl
     d_exp_huh_d_u_star = matrix.col(
         [h**2, k**2, l**2, 2 * h * k, 2 * h * l, 2 * k * l])
     for i_scatterer, scatterer in enumerate(self.scatterers):
         site_symmetry_ops = None
         if (self.site_symmetry_table.is_special_position(i_scatterer)):
             site_symmetry_ops = self.site_symmetry_table.get(i_scatterer)
             site_constraints = site_symmetry_ops.site_constraints()
             if (scatterer.flags.use_u_aniso()):
                 adp_constraints = site_symmetry_ops.adp_constraints()
         w = scatterer.weight()
         wwo = scatterer.weight_without_occupancy()
         if (not scatterer.flags.use_u_aniso()):
             huh = scatterer.u_iso * self.d_star_sq
             dw = math.exp(mtps * huh)
         gaussian = self.scattering_type_registry.gaussian_not_optional(
             scattering_type=scatterer.scattering_type)
         f0 = gaussian.at_d_star_sq(self.d_star_sq)
         ffp = f0 + scatterer.fp
         fdp = scatterer.fdp
         ff = ffp + 1j * fdp
         d_site = matrix.col([0, 0, 0])
         if (not scatterer.flags.use_u_aniso()):
             d_u_iso = 0
             d_u_star = None
         else:
             d_u_iso = None
             d_u_star = matrix.col([0, 0, 0, 0, 0, 0])
         d_occ = 0j
         d_fp = 0j
         d_fdp = 0j
         for s in self.space_group:
             r = s.r().as_rational().as_float()
             s_site = s * scatterer.site
             alpha = matrix.col(s_site).dot(tphkl)
             if (scatterer.flags.use_u_aniso()):
                 s_u_star_s = r * matrix.sym(
                     sym_mat3=scatterer.u_star) * r.transpose()
                 huh = (matrix.row(self.hkl) * s_u_star_s).dot(
                     matrix.col(self.hkl))
                 dw = math.exp(mtps * huh)
             e = cmath.exp(1j * alpha)
             site_gtmx = r.transpose()
             d_site += site_gtmx * (w * dw * ff * e * 1j * tphkl)
             if (not scatterer.flags.use_u_aniso()):
                 d_u_iso += w * dw * ff * e * mtps * self.d_star_sq
             else:
                 u_star_gtmx = matrix.sqr(
                     tensor_rank_2_gradient_transform_matrix(r))
                 d_u_star += u_star_gtmx * (w * dw * ff * e * mtps *
                                            d_exp_huh_d_u_star)
             d_occ += wwo * dw * ff * e
             d_fp += w * dw * e
             d_fdp += w * dw * e * 1j
         if (site_symmetry_ops is not None):
             gsm = site_constraints.gradient_sum_matrix()
             gsm = matrix.rec(elems=gsm, n=gsm.focus())
             d_site = gsm * d_site
             if (scatterer.flags.use_u_aniso()):
                 gsm = adp_constraints.gradient_sum_matrix()
                 gsm = matrix.rec(elems=gsm, n=gsm.focus())
                 d_u_star = gsm * d_u_star
         result = flex.complex_double(d_site)
         if (not scatterer.flags.use_u_aniso()):
             result.append(d_u_iso)
         else:
             result.extend(flex.complex_double(d_u_star))
         result.extend(flex.complex_double([d_occ, d_fp, d_fdp]))
         yield result
Exemple #44
0
    def __init__(self, crystal_symmetry, cell_covariance_matrix=None, format="coreCIF", numeric_format="%.3f"):
        self.format = format.lower()
        assert self.format in ("corecif", "mmcif")
        if self.format == "mmcif":
            self.separator = "."
        else:
            self.separator = "_"
        assert numeric_format.startswith("%")
        self.cif_block = model.block()
        cell_prefix = "_cell%s" % self.separator
        if crystal_symmetry.space_group() is not None:
            sym_loop = model.loop(
                data=OrderedDict(
                    (
                        (
                            "_space_group_symop" + self.separator + "id",
                            range(1, len(crystal_symmetry.space_group()) + 1),
                        ),
                        (
                            "_space_group_symop" + self.separator + "operation_xyz",
                            [s.as_xyz() for s in crystal_symmetry.space_group()],
                        ),
                    )
                )
            )
            self.cif_block.add_loop(sym_loop)
            sg_prefix = "_space_group%s" % self.separator
            sg_type = crystal_symmetry.space_group_info().type()
            sg = sg_type.group()
            self.cif_block[sg_prefix + "crystal_system"] = sg.crystal_system().lower()
            self.cif_block[sg_prefix + "IT_number"] = sg_type.number()
            self.cif_block[sg_prefix + "name_H-M_alt"] = sg_type.lookup_symbol()
            self.cif_block[sg_prefix + "name_Hall"] = sg_type.hall_symbol()

            sg_prefix = "_symmetry%s" % self.separator
            self.cif_block[sg_prefix + "space_group_name_H-M"] = sg_type.lookup_symbol()
            self.cif_block[sg_prefix + "space_group_name_Hall"] = sg_type.hall_symbol()
            self.cif_block[sg_prefix + "Int_Tables_number"] = sg_type.number()

        if crystal_symmetry.unit_cell() is not None:
            uc = crystal_symmetry.unit_cell()
            params = list(uc.parameters())
            volume = uc.volume()
            if cell_covariance_matrix is not None:
                diag = cell_covariance_matrix.matrix_packed_u_diagonal()
                for i in range(6):
                    if diag[i] > 0:
                        params[i] = format_float_with_su(params[i], math.sqrt(diag[i]))
                d_v_d_params = matrix.row(uc.d_volume_d_params())
                vcv = matrix.sqr(cell_covariance_matrix.matrix_packed_u_as_symmetric())
                var_v = (d_v_d_params * vcv).dot(d_v_d_params)
                volume = format_float_with_su(volume, math.sqrt(var_v))
                numeric_format = "%s"
            a, b, c, alpha, beta, gamma = params
            self.cif_block[cell_prefix + "length_a"] = numeric_format % a
            self.cif_block[cell_prefix + "length_b"] = numeric_format % b
            self.cif_block[cell_prefix + "length_c"] = numeric_format % c
            self.cif_block[cell_prefix + "angle_alpha"] = numeric_format % alpha
            self.cif_block[cell_prefix + "angle_beta"] = numeric_format % beta
            self.cif_block[cell_prefix + "angle_gamma"] = numeric_format % gamma
            self.cif_block[cell_prefix + "volume"] = numeric_format % volume
Exemple #45
0
def run(server_info, inp, status):
    print "<pre>"
    from scitbx import matrix
    p = p_from_string(string=inp.cb_expr)
    assert inp.p_or_q in ["P", "Q"]
    if (inp.p_or_q == "Q"):
        p = p.inverse()
    assert inp.p_transpose in ["off", "on"]
    if (inp.p_transpose == "on"):
        p = matrix.rt((p.r.transpose(), p.t))
    print "P:"
    display_rt(p)
    print
    q = p.inverse()
    print "Q:"
    display_rt(q)
    print
    if (len(inp.obj_expr.strip()) != 0):
        if (inp.obj_type in ["xyz", "hkl"]):
            triple = xyz_from_string(string=inp.obj_expr)
            if (inp.obj_type == "xyz"):
                print "Transformation law: (Q,q) xyz"
                print
                print "  xyz:", triple
                print
                print "  xyz':", (q.r * matrix.col(triple) + q.t).elems
                print
            else:
                print "Transformation law: hkl P"
                print
                print "  hkl:", triple
                print
                print "  hkl':", (matrix.row(triple) * p.r).elems
                print
        elif (inp.obj_type == "unit_cell"):
            from cctbx import uctbx
            uc = uctbx.unit_cell(inp.obj_expr)
            print "Transformation law: Pt G P"
            print
            print "unit cell:", uc
            print
            g = matrix.sym(sym_mat3=uc.metrical_matrix())
            print "metrical matrix:"
            display_r(g)
            print
            gp = p.r.transpose() * g * p.r
            print "metrical matrix':"
            display_r(gp)
            print
            ucp = uctbx.unit_cell(metrical_matrix=gp.as_sym_mat3())
            print "unit cell':", ucp
            print
        elif (inp.obj_type == "Ww"):
            w = w_from_string(string=inp.obj_expr)
            print "Transformation law: (Q,q) (W,w) (P,p)"
            print
            print "(W, w):"
            display_rt(w)
            print
            wp = q * w * p
            print "(W, w)':"
            display_rt(wp)
            print
        else:
            raise RuntimeError("Unknown obj_type: %s" % inp.obj_type)
    print "</pre>"
Exemple #46
0
    def __init__(self, xray_structure, covariance_matrix=None, cell_covariance_matrix=None):
        crystal_symmetry_as_cif_block.__init__(
            self, xray_structure.crystal_symmetry(), cell_covariance_matrix=cell_covariance_matrix
        )
        scatterers = xray_structure.scatterers()
        uc = xray_structure.unit_cell()
        if covariance_matrix is not None:
            param_map = xray_structure.parameter_map()
            covariance_diagonal = covariance_matrix.matrix_packed_u_diagonal()
            u_star_to_u_cif_linear_map_pow2 = flex.pow2(flex.double(uc.u_star_to_u_cif_linear_map()))
            u_star_to_u_iso_linear_form = matrix.row(uc.u_star_to_u_iso_linear_form())
        fmt = "%.6f"

        # _atom_site_* loop
        atom_site_loop = model.loop(
            header=(
                "_atom_site_label",
                "_atom_site_type_symbol",
                "_atom_site_fract_x",
                "_atom_site_fract_y",
                "_atom_site_fract_z",
                "_atom_site_U_iso_or_equiv",
                "_atom_site_adp_type",
                "_atom_site_occupancy",
            )
        )
        for i_seq, sc in enumerate(scatterers):
            site = occu = u_iso_or_equiv = None
            # site
            if covariance_matrix is not None:
                params = param_map[i_seq]
                if sc.flags.grad_site() and params.site >= 0:
                    site = []
                    for i in range(3):
                        site.append(format_float_with_su(sc.site[i], math.sqrt(covariance_diagonal[params.site + i])))
                # occupancy
                if sc.flags.grad_occupancy() and params.occupancy >= 0:
                    occu = format_float_with_su(sc.occupancy, math.sqrt(covariance_diagonal[params.occupancy]))
                # Uiso/eq
                if sc.flags.grad_u_iso() or sc.flags.grad_u_aniso():
                    if sc.flags.grad_u_iso():
                        u_iso_or_equiv = format_float_with_su(
                            sc.u_iso, math.sqrt(covariance.variance_for_u_iso(i_seq, covariance_matrix, param_map))
                        )
                    else:
                        cov = covariance.extract_covariance_matrix_for_u_aniso(
                            i_seq, covariance_matrix, param_map
                        ).matrix_packed_u_as_symmetric()
                        var = (u_star_to_u_iso_linear_form * matrix.sqr(cov)).dot(u_star_to_u_iso_linear_form)
                        u_iso_or_equiv = format_float_with_su(sc.u_iso_or_equiv(uc), math.sqrt(var))

            if site is None:
                site = [fmt % sc.site[i] for i in range(3)]
            if occu is None:
                occu = fmt % sc.occupancy
            if u_iso_or_equiv is None:
                u_iso_or_equiv = fmt % sc.u_iso_or_equiv(uc)

            if sc.flags.use_u_aniso():
                adp_type = "Uani"
            else:
                adp_type = "Uiso"
            atom_site_loop.add_row(
                (sc.label, sc.scattering_type, site[0], site[1], site[2], u_iso_or_equiv, adp_type, occu)
            )
        self.cif_block.add_loop(atom_site_loop)

        # _atom_site_aniso_* loop
        aniso_scatterers = scatterers.select(scatterers.extract_use_u_aniso())
        if aniso_scatterers.size():
            labels = list(scatterers.extract_labels())
            aniso_loop = model.loop(
                header=(
                    "_atom_site_aniso_label",
                    "_atom_site_aniso_U_11",
                    "_atom_site_aniso_U_22",
                    "_atom_site_aniso_U_33",
                    "_atom_site_aniso_U_12",
                    "_atom_site_aniso_U_13",
                    "_atom_site_aniso_U_23",
                )
            )
            for sc in aniso_scatterers:
                u_cif = adptbx.u_star_as_u_cif(uc, sc.u_star)
                if covariance_matrix is not None:
                    row = [sc.label]
                    idx = param_map[labels.index(sc.label)].u_aniso
                    if idx > -1:
                        var = covariance_diagonal[idx : idx + 6] * u_star_to_u_cif_linear_map_pow2
                        for i in range(6):
                            if var[i] > 0:
                                row.append(format_float_with_su(u_cif[i], math.sqrt(var[i])))
                            else:
                                row.append(fmt % u_cif[i])
                    else:
                        row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
                else:
                    row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
                aniso_loop.add_row(row)
            self.cif_block.add_loop(aniso_loop)
            self.cif_block.add_loop(atom_type_cif_loop(xray_structure))
Exemple #47
0
def integrate_coset(self, experiments, indexed):
        TRANS = self.params.integration.coset.transformation

        # here get a deepcopy that we are not afraid to modify:
        experiments_local = copy.deepcopy(experiments)

        print("*" * 80)
        print("Coset Reflections for modeling or validating the background")
        print("*" * 80)
        from dials.algorithms.profile_model.factory import ProfileModelFactory
        from dials.algorithms.integration.integrator import create_integrator

        # XXX Fixme later implement support for non-primitive lattices NKS
        base_set = miller_set( crystal_symmetry = symmetry(
            unit_cell = experiments_local[0].crystal.get_unit_cell(),
            space_group = experiments_local[0].crystal.get_space_group()),
            indices = indexed["miller_index"]
          )
        triclinic = base_set.customized_copy(
          crystal_symmetry=symmetry(unit_cell = experiments_local[0].crystal.get_unit_cell(),space_group="P1"))

        # ================
        # Compute the profile model
        # Predict the reflections
        # Create the integrator
        # This creates a reference to the experiment, not a copy:
        experiments_local = ProfileModelFactory.create(self.params, experiments_local, indexed)
        # for debug SLT[TRANS].show_summary()

        for e in experiments_local:
          e.crystal.set_space_group(triclinic.space_group())
          Astar = e.crystal.get_A()
          # debug OriAstar = crystal_orientation(Astar,True)
          # debug OriAstar.show(legend="old ")
          Astarprime = sqr(Astar)* ( sqr(SLT[TRANS]._reindex_N).transpose().inverse() )
          e.crystal.set_A(Astarprime)
          # debug OriAstarprime = crystal_orientation(Astarprime,True)
          # debug OriAstarprime.show(legend="new ")

        print("Predicting coset reflections")
        print("")
        predicted = flex.reflection_table.from_predictions_multi(
            experiments_local,
            dmin=self.params.prediction.d_min,
            dmax=self.params.prediction.d_max,
            margin=self.params.prediction.margin,
            force_static=self.params.prediction.force_static,
        )
        print("sublattice total predictions %d"%len(predicted))

        # filter the sublattice, keep only the coset indices
        miller = predicted["miller_index"]
        # coset of modulus 2, wherein there is a binary choice
        # see Sauter & Zwart, Acta D (2009) 65:553, Table 1; select the valid coset using eqn(5).
        coset_select_algorithm_2 = flex.bool()
        M_mat = SLT[TRANS].matS() # the transformation
        M_p = M_mat.inverse()
        for idx in miller:
          H_row = row(idx)
          h_orig_setting = H_row * M_p
          on_coset=False
          for icom in h_orig_setting.elems:
            if icom.denominator() > 1: on_coset=True; break
          coset_select_algorithm_2.append(on_coset)
        predicted = predicted.select(coset_select_algorithm_2)
        print("of which %d are in coset %d"%(len(predicted), TRANS))

        print("")
        integrator = create_integrator(self.params, experiments_local, predicted)

        # Integrate the reflections
        integrated = integrator.integrate()

        # Delete the shoeboxes used for intermediate calculations, if requested
        if self.params.integration.debug.delete_shoeboxes and "shoebox" in integrated:
            del integrated["shoebox"]

        if self.params.output.composite_output:
            if (
                self.params.output.coset_experiments_filename
                or self.params.output.coset_filename
            ):
                assert (
                    self.params.output.coset_experiments_filename is not None
                    and self.params.output.coset_filename is not None
                )
                n = len(self.all_coset_experiments)
                self.all_coset_experiments.extend(experiments_local)
                for i, experiment in enumerate(experiments_local):
                    refls = integrated.select(integrated["id"] == i)
                    refls["id"] = flex.int(len(refls), n)
                    del refls.experiment_identifiers()[i]
                    refls.experiment_identifiers()[n] = experiment.identifier
                    self.all_coset_reflections.extend(refls)
                    n += 1
        else:
            # Dump experiments to disk
            if self.params.output.coset_experiments_filename:

                experiments_local.as_json(self.params.output.coset_experiments_filename)

            if self.params.output.coset_filename:
                # Save the reflections
                self.save_reflections(
                    integrated, self.params.output.coset_filename
                )

        rmsd_indexed, _ = calc_2D_rmsd_and_displacements(indexed)
        log_str = "coset RMSD indexed (px): %f\n" % (rmsd_indexed)
        log_str += "integrated %d\n"%len(integrated)
        for i in range(6):
            bright_integrated = integrated.select(
                (
                    integrated["intensity.sum.value"]
                    / flex.sqrt(integrated["intensity.sum.variance"])
                )
                >= i
            )
            if len(bright_integrated) > 0:
                rmsd_integrated, _ = calc_2D_rmsd_and_displacements(bright_integrated)
            else:
                rmsd_integrated = 0
            log_str += (
                "N reflections integrated at I/sigI >= %d: % 4d, RMSD (px): %f\n"
                % (i, len(bright_integrated), rmsd_integrated)
            )

        for crystal_model in experiments_local.crystals():
            if hasattr(crystal_model, "get_domain_size_ang"):
                log_str += (
                    ". Final ML model: domain size angstroms: %f, half mosaicity degrees: %f"
                    % (
                        crystal_model.get_domain_size_ang(),
                        crystal_model.get_half_mosaicity_deg(),
                    )
                )

        print(log_str)
        print("")
Exemple #48
0
    def __init__(self, params):
        import cPickle as pickle
        from dxtbx.model import BeamFactory
        from dxtbx.model import DetectorFactory
        from dxtbx.model.crystal import crystal_model
        from cctbx.crystal_orientation import crystal_orientation, basis_type
        from dxtbx.model import Experiment, ExperimentList
        from scitbx import matrix
        self.experiments = ExperimentList()
        self.unique_file_names = []

        self.params = params
        data = pickle.load(
            open(self.params.output.prefix + "_frame.pickle", "rb"))
        frames_text = data.split("\n")

        for item in frames_text:
            tokens = item.split(' ')
            wavelength = float(tokens[order_dict["wavelength"]])

            beam = BeamFactory.simple(wavelength=wavelength)

            detector = DetectorFactory.simple(
                sensor=DetectorFactory.sensor(
                    "PAD"),  # XXX shouldn't hard code for XFEL
                distance=float(tokens[order_dict["distance"]]),
                beam_centre=[
                    float(tokens[order_dict["beam_x"]]),
                    float(tokens[order_dict["beam_y"]])
                ],
                fast_direction="+x",
                slow_direction="+y",
                pixel_size=[self.params.pixel_size, self.params.pixel_size],
                image_size=[1795,
                            1795],  # XXX obviously need to figure this out
            )

            reciprocal_matrix = matrix.sqr([
                float(tokens[order_dict[k]]) for k in [
                    'res_ori_1', 'res_ori_2', 'res_ori_3', 'res_ori_4',
                    'res_ori_5', 'res_ori_6', 'res_ori_7', 'res_ori_8',
                    'res_ori_9'
                ]
            ])
            ORI = crystal_orientation(reciprocal_matrix, basis_type.reciprocal)
            direct = matrix.sqr(ORI.direct_matrix())
            crystal = crystal_model(
                real_space_a=matrix.row(direct[0:3]),
                real_space_b=matrix.row(direct[3:6]),
                real_space_c=matrix.row(direct[6:9]),
                space_group_symbol=self.params.target_space_group.type().
                lookup_symbol(),
                mosaicity=float(tokens[order_dict["half_mosaicity_deg"]]),
            )
            crystal.domain_size = float(tokens[order_dict["domain_size_ang"]])
            #if isoform is not None:
            #  newB = matrix.sqr(isoform.fractionalization_matrix()).transpose()
            #  crystal.set_B(newB)

            self.experiments.append(
                Experiment(
                    beam=beam,
                    detector=None,  #dummy for now
                    crystal=crystal))
            self.unique_file_names.append(
                tokens[order_dict["unique_file_name"]])

        self.show_summary()
def run(server_info, inp, status):
  print "<pre>"
  from scitbx import matrix
  p = p_from_string(string=inp.cb_expr)
  assert inp.p_or_q in ["P", "Q"]
  if (inp.p_or_q == "Q"):
    p = p.inverse()
  assert inp.p_transpose in ["off", "on"]
  if (inp.p_transpose == "on"):
    p = matrix.rt((p.r.transpose(), p.t))
  print "P:"
  display_rt(p)
  print
  q = p.inverse()
  print "Q:"
  display_rt(q)
  print
  if (len(inp.obj_expr.strip()) != 0):
    if (inp.obj_type in ["xyz", "hkl"]):
      triple = xyz_from_string(string=inp.obj_expr)
      if (inp.obj_type == "xyz"):
        print "Transformation law: (Q,q) xyz"
        print
        print "  xyz:", triple
        print
        print "  xyz':", (
          q.r * matrix.col(triple) + q.t).elems
        print
      else:
        print "Transformation law: hkl P"
        print
        print "  hkl:", triple
        print
        print "  hkl':", (matrix.row(triple) * p.r).elems
        print
    elif (inp.obj_type == "unit_cell"):
      from cctbx import uctbx
      uc = uctbx.unit_cell(inp.obj_expr)
      print "Transformation law: Pt G P"
      print
      print "unit cell:", uc
      print
      g = matrix.sym(sym_mat3=uc.metrical_matrix())
      print "metrical matrix:"
      display_r(g)
      print
      gp = p.r.transpose() * g * p.r
      print "metrical matrix':"
      display_r(gp)
      print
      ucp = uctbx.unit_cell(metrical_matrix=gp.as_sym_mat3())
      print "unit cell':", ucp
      print
    elif (inp.obj_type == "Ww"):
      w = w_from_string(string=inp.obj_expr)
      print "Transformation law: (Q,q) (W,w) (P,p)"
      print
      print "(W, w):"
      display_rt(w)
      print
      wp = q * w * p
      print "(W, w)':"
      display_rt(wp)
      print
    else:
      raise RuntimeError("Unknown obj_type: %s" % inp.obj_type)
  print "</pre>"
Exemple #50
0
 def d2f_d_params(self):
     tphkl = 2 * math.pi * flex.double(self.hkl)
     tphkl_outer = tphkl.matrix_outer_product(tphkl) \
       .matrix_symmetric_as_packed_u()
     h, k, l = self.hkl
     d_exp_huh_d_u_star = flex.double(
         [h**2, k**2, l**2, 2 * h * k, 2 * h * l, 2 * k * l])
     d2_exp_huh_d_u_star_u_star = d_exp_huh_d_u_star.matrix_outer_product(
         d_exp_huh_d_u_star).matrix_symmetric_as_packed_u()
     for i_scatterer, scatterer in enumerate(self.scatterers):
         site_symmetry_ops = None
         if (self.site_symmetry_table.is_special_position(i_scatterer)):
             site_symmetry_ops = self.site_symmetry_table.get(i_scatterer)
             site_constraints = site_symmetry_ops.site_constraints()
             if (scatterer.flags.use_u_aniso()):
                 adp_constraints = site_symmetry_ops.adp_constraints()
         w = scatterer.weight()
         wwo = scatterer.weight_without_occupancy()
         if (not scatterer.flags.use_u_aniso()):
             huh = scatterer.u_iso * self.d_star_sq
             dw = math.exp(mtps * huh)
         gaussian = self.scattering_type_registry.gaussian_not_optional(
             scattering_type=scatterer.scattering_type)
         f0 = gaussian.at_d_star_sq(self.d_star_sq)
         ffp = f0 + scatterer.fp
         fdp = scatterer.fdp
         ff = (ffp + 1j * fdp)
         d2_site_site = flex.complex_double(3 * (3 + 1) // 2, 0j)
         if (not scatterer.flags.use_u_aniso()):
             d2_site_u_iso = flex.complex_double(flex.grid(3, 1), 0j)
             d2_site_u_star = None
         else:
             d2_site_u_iso = None
             d2_site_u_star = flex.complex_double(flex.grid(3, 6), 0j)
         d2_site_occ = flex.complex_double(flex.grid(3, 1), 0j)
         d2_site_fp = flex.complex_double(flex.grid(3, 1), 0j)
         d2_site_fdp = flex.complex_double(flex.grid(3, 1), 0j)
         if (not scatterer.flags.use_u_aniso()):
             d2_u_iso_u_iso = 0j
             d2_u_iso_occ = 0j
             d2_u_iso_fp = 0j
             d2_u_iso_fdp = 0j
         else:
             d2_u_star_u_star = flex.complex_double(6 * (6 + 1) // 2, 0j)
             d2_u_star_occ = flex.complex_double(flex.grid(6, 1), 0j)
             d2_u_star_fp = flex.complex_double(flex.grid(6, 1), 0j)
             d2_u_star_fdp = flex.complex_double(flex.grid(6, 1), 0j)
         d2_occ_fp = 0j
         d2_occ_fdp = 0j
         for s in self.space_group:
             r = s.r().as_rational().as_float()
             s_site = s * scatterer.site
             alpha = tphkl.dot(flex.double(s_site))
             if (scatterer.flags.use_u_aniso()):
                 s_u_star_s = r * matrix.sym(
                     sym_mat3=scatterer.u_star) * r.transpose()
                 huh = (matrix.row(self.hkl) * s_u_star_s).dot(
                     matrix.col(self.hkl))
                 dw = math.exp(mtps * huh)
             e = cmath.exp(1j * alpha)
             site_gtmx = flex.double(r.transpose())
             site_gtmx.reshape(flex.grid(3, 3))
             d2_site_site += (w * dw * ff * e * (-1)) * (
                 site_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
                     tphkl_outer))
             if (not scatterer.flags.use_u_aniso()):
                 d2_site_u_iso += (w * dw * ff * e * 1j * mtps * self.d_star_sq) \
                   * site_gtmx.matrix_multiply(tphkl)
             else:
                 u_star_gtmx = tensor_rank_2_gradient_transform_matrix(r)
                 d2_site_u_star += (w * dw * ff * e * 1j * mtps) \
                   * site_gtmx.matrix_multiply(
                       tphkl.matrix_outer_product(d_exp_huh_d_u_star)) \
                         .matrix_multiply(u_star_gtmx.matrix_transpose())
             site_gtmx_tphkl = site_gtmx.matrix_multiply(tphkl)
             d2_site_occ += (wwo * dw * ff * e * 1j) * site_gtmx_tphkl
             d2_site_fp += (w * dw * e * 1j) * site_gtmx_tphkl
             d2_site_fdp += (w * dw * e * (-1)) * site_gtmx_tphkl
             if (not scatterer.flags.use_u_aniso()):
                 d2_u_iso_u_iso += w * dw * ff * e * (mtps *
                                                      self.d_star_sq)**2
                 d2_u_iso_occ += wwo * dw * ff * e * mtps * self.d_star_sq
                 d2_u_iso_fp += w * dw * e * mtps * self.d_star_sq
                 d2_u_iso_fdp += 1j * w * dw * e * mtps * self.d_star_sq
             else:
                 d2_u_star_u_star +=(w * dw * ff * e * mtps**2) \
                   * u_star_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
                       d2_exp_huh_d_u_star_u_star)
                 u_star_gtmx_d_exp_huh_d_u_star = u_star_gtmx.matrix_multiply(
                     d_exp_huh_d_u_star)
                 d2_u_star_occ += (wwo * dw * ff * e * mtps) \
                   * u_star_gtmx_d_exp_huh_d_u_star
                 d2_u_star_fp += (w * dw * e * mtps) \
                   * u_star_gtmx_d_exp_huh_d_u_star
                 d2_u_star_fdp += (w * dw * 1j * e * mtps) \
                   * u_star_gtmx_d_exp_huh_d_u_star
             d2_occ_fp += wwo * dw * e
             d2_occ_fdp += wwo * dw * e * 1j
         if (site_symmetry_ops is None):
             i_u = 3
         else:
             i_u = site_constraints.n_independent_params()
         if (not scatterer.flags.use_u_aniso()):
             i_occ = i_u + 1
         elif (site_symmetry_ops is None):
             i_occ = i_u + 6
         else:
             i_occ = i_u + adp_constraints.n_independent_params()
         i_fp, i_fdp, np = i_occ + 1, i_occ + 2, i_occ + 3
         if (site_symmetry_ops is not None):
             gsm = site_constraints.gradient_sum_matrix()
             d2_site_site = gsm.matrix_multiply_packed_u_multiply_lhs_transpose(
                 packed_u=d2_site_site)
             if (not scatterer.flags.use_u_aniso()):
                 d2_site_u_iso = gsm.matrix_multiply(d2_site_u_iso)
             else:
                 d2_site_u_star = gsm.matrix_multiply(d2_site_u_star)
             d2_site_occ = gsm.matrix_multiply(d2_site_occ)
             d2_site_fp = gsm.matrix_multiply(d2_site_fp)
             d2_site_fdp = gsm.matrix_multiply(d2_site_fdp)
             if (scatterer.flags.use_u_aniso()):
                 gsm = adp_constraints.gradient_sum_matrix()
                 d2_site_u_star = d2_site_u_star.matrix_multiply(
                     gsm.matrix_transpose())
                 d2_u_star_u_star = gsm \
                   .matrix_multiply_packed_u_multiply_lhs_transpose(
                     packed_u=d2_u_star_u_star)
                 d2_u_star_occ = gsm.matrix_multiply(d2_u_star_occ)
                 d2_u_star_fp = gsm.matrix_multiply(d2_u_star_fp)
                 d2_u_star_fdp = gsm.matrix_multiply(d2_u_star_fdp)
         dp = flex.complex_double(flex.grid(np, np), 0j)
         paste = dp.matrix_paste_block_in_place
         paste(d2_site_site.matrix_packed_u_as_symmetric(), 0, 0)
         if (not scatterer.flags.use_u_aniso()):
             paste(d2_site_u_iso, 0, i_u)
             paste(d2_site_u_iso.matrix_transpose(), i_u, 0)
         else:
             paste(d2_site_u_star, 0, i_u)
             paste(d2_site_u_star.matrix_transpose(), i_u, 0)
         paste(d2_site_occ, 0, i_occ)
         paste(d2_site_occ.matrix_transpose(), i_occ, 0)
         paste(d2_site_fp, 0, i_fp)
         paste(d2_site_fp.matrix_transpose(), i_fp, 0)
         paste(d2_site_fdp, 0, i_fdp)
         paste(d2_site_fdp.matrix_transpose(), i_fdp, 0)
         if (not scatterer.flags.use_u_aniso()):
             dp[i_u * np + i_u] = d2_u_iso_u_iso
             dp[i_u * np + i_occ] = d2_u_iso_occ
             dp[i_occ * np + i_u] = d2_u_iso_occ
             dp[i_u * np + i_fp] = d2_u_iso_fp
             dp[i_fp * np + i_u] = d2_u_iso_fp
             dp[i_u * np + i_fdp] = d2_u_iso_fdp
             dp[i_fdp * np + i_u] = d2_u_iso_fdp
         else:
             paste(d2_u_star_u_star.matrix_packed_u_as_symmetric(), i_u,
                   i_u)
             paste(d2_u_star_occ, i_u, i_occ)
             paste(d2_u_star_occ.matrix_transpose(), i_occ, i_u)
             paste(d2_u_star_fp, i_u, i_fp)
             paste(d2_u_star_fp.matrix_transpose(), i_fp, i_u)
             paste(d2_u_star_fdp, i_u, i_fdp)
             paste(d2_u_star_fdp.matrix_transpose(), i_fdp, i_u)
         dp[i_occ * np + i_fp] = d2_occ_fp
         dp[i_fp * np + i_occ] = d2_occ_fp
         dp[i_occ * np + i_fdp] = d2_occ_fdp
         dp[i_fdp * np + i_occ] = d2_occ_fdp
         yield dp
 def __init__(self, h, site_constraints, independent_params):
   self.h = matrix.row(h)
   self.site_constraints = site_constraints
   self.independent_params = independent_params
   self.site = matrix.col(self.site_constraints.all_params(
     independent_params=self.independent_params))
def exercise_geometry():
  xs = quartz()
  uc = xs.unit_cell()
  flags = xs.scatterer_flags()
  for f in flags:
    f.set_grad_site(True)
  xs.set_scatterer_flags(flags)
  cov = flex.double((1e-8,1e-9,2e-9,3e-9,4e-9,5e-9,
                          2e-8,1e-9,2e-9,3e-9,4e-9,
                               3e-8,1e-9,2e-9,3e-9,
                                    2e-8,1e-9,2e-9,
                                         3e-8,1e-9,
                                              4e-8))
  cell_vcv = flex.double((3e-2,3e-2,0,0,0,0,
                               3e-2,0,0,0,0,
                                 4e-2,0,0,0,
                                      0,0,0,
                                        0,0,
                                          0))
  param_map = xs.parameter_map()
  cov_cart = covariance.orthogonalize_covariance_matrix(cov, uc, param_map)
  O = matrix.sqr(uc.orthogonalization_matrix())
  F = matrix.sqr(uc.fractionalization_matrix())
  sites_cart = xs.sites_cart()
  sites_frac = xs.sites_frac()
  # distances
  rt_mx_ji = sgtbx.rt_mx('-y,x-y,z-1/3')
  sites = (sites_cart[0], uc.orthogonalize(rt_mx_ji*sites_frac[1]))
  d = geometry.distance(sites)
  assert approx_equal(d.distance_model, 1.6159860469110217)
  v = matrix.col(sites[1]) - matrix.col(sites[0])
  r_inv_cart = (O * matrix.sqr(rt_mx_ji.r().inverse().as_double()) * F)
  g = d.d_distance_d_sites()
  g = matrix.row(g[0] + tuple(r_inv_cart*matrix.col(g[1])))
  f = g * matrix.sqr(cov_cart.matrix_packed_u_as_symmetric()) * g.transpose()
  assert approx_equal(d.variance(cov_cart, uc, rt_mx_ji), f[0], eps=1e-15)
  assert approx_equal(
    0.0018054494791580823, d.variance(cov_cart, cell_vcv, uc, rt_mx_ji))
  rt_mx_ji = sgtbx.rt_mx('x+1,y,z')
  sites = (sites_cart[0], uc.orthogonalize(rt_mx_ji*sites_frac[0]))
  d = geometry.distance(sites)
  assert approx_equal(d.distance_model, uc.parameters()[0])
  assert approx_equal(cell_vcv.matrix_packed_u_diagonal()[0],
                      d.variance(cov_cart, cell_vcv, uc, rt_mx_ji))
  # angles
  rt_mx_ji = sgtbx.rt_mx('x-y,x,z-2/3')
  rt_mx_ki = sgtbx.rt_mx('-y,x-y,z-1/3')
  r_inv_cart_ji = (O * matrix.sqr(rt_mx_ji.r().inverse().as_double()) * F)
  r_inv_cart_ki = (O * matrix.sqr(rt_mx_ki.r().inverse().as_double()) * F)
  cov_a = covariance.extract_covariance_matrix_for_sites(flex.size_t([1,0,1]), cov_cart, param_map)
  sites = (uc.orthogonalize(rt_mx_ji*sites_frac[1]),
           sites_cart[0],
           uc.orthogonalize(rt_mx_ki*sites_frac[1]))
  a = geometry.angle(sites)
  assert approx_equal(a.angle_model, 101.30738566828551)
  g = a.d_angle_d_sites()
  g = matrix.row(tuple(r_inv_cart_ji*matrix.col(g[0])) + g[1] +
                 tuple(r_inv_cart_ki*matrix.col(g[2])))
  f = g * matrix.sqr(cov_a.matrix_packed_u_as_symmetric()) * g.transpose()
  assert approx_equal(
    a.variance(cov_a, uc, (rt_mx_ji, sgtbx.rt_mx(), rt_mx_ki)), f[0], eps=1e-15)
  assert approx_equal(0.0042632511984529199,
    a.variance(cov_a, cell_vcv, uc, (rt_mx_ji, sgtbx.rt_mx(), rt_mx_ki)))
 def d2f_d_params_diag(self):
   tphkl = 2 * math.pi * flex.double(self.hkl)
   tphkl_outer = tphkl.matrix_outer_product(tphkl) \
     .matrix_symmetric_as_packed_u()
   h,k,l = self.hkl
   d_exp_huh_d_u_star = flex.double([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   d2_exp_huh_d_u_star_u_star = d_exp_huh_d_u_star.matrix_outer_product(
     d_exp_huh_d_u_star).matrix_symmetric_as_packed_u()
   for i_scatterer,scatterer in enumerate(self.scatterers):
     site_symmetry_ops = None
     if (self.site_symmetry_table.is_special_position(i_scatterer)):
       site_symmetry_ops = self.site_symmetry_table.get(i_scatterer)
       site_constraints = site_symmetry_ops.site_constraints()
       if (scatterer.flags.use_u_aniso()):
         adp_constraints = site_symmetry_ops.adp_constraints()
     w = scatterer.weight()
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     gaussian = self.scattering_type_registry.gaussian_not_optional(
       scattering_type=scatterer.scattering_type)
     f0 = gaussian.at_d_star_sq(self.d_star_sq)
     ffp = f0 + scatterer.fp
     fdp = scatterer.fdp
     ff = (ffp + 1j * fdp)
     d2_site_site = flex.complex_double(3*(3+1)//2, 0j)
     if (not scatterer.flags.use_u_aniso()):
       d2_u_iso_u_iso = 0j
     else:
       d2_u_star_u_star = flex.complex_double(6*(6+1)//2, 0j)
     for s in self.space_group:
       r = s.r().as_rational().as_float()
       s_site = s * scatterer.site
       alpha = tphkl.dot(flex.double(s_site))
       if (scatterer.flags.use_u_aniso()):
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       site_gtmx = flex.double(r.transpose())
       site_gtmx.reshape(flex.grid(3,3))
       d2_site_site += (w * dw * ff * e * (-1)) * (
         site_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
           tphkl_outer))
       if (not scatterer.flags.use_u_aniso()):
         d2_u_iso_u_iso += w * dw * ff * e * (mtps * self.d_star_sq)**2
       else:
         u_star_gtmx = tensor_rank_2_gradient_transform_matrix(r)
         d2_u_star_u_star +=(w * dw * ff * e * mtps**2) \
           * u_star_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
               d2_exp_huh_d_u_star_u_star)
     if (site_symmetry_ops is None):
       i_u = 3
     else:
       i_u = site_constraints.n_independent_params()
     if (not scatterer.flags.use_u_aniso()):
       i_occ = i_u + 1
     elif (site_symmetry_ops is None):
       i_occ = i_u + 6
     else:
       i_occ = i_u + adp_constraints.n_independent_params()
     np = i_occ+3
     if (site_symmetry_ops is not None):
       gsm = site_constraints.gradient_sum_matrix()
       d2_site_site = gsm.matrix_multiply_packed_u_multiply_lhs_transpose(
         packed_u=d2_site_site)
       if (scatterer.flags.use_u_aniso()):
         gsm = adp_constraints.gradient_sum_matrix()
         d2_u_star_u_star = gsm \
           .matrix_multiply_packed_u_multiply_lhs_transpose(
             packed_u=d2_u_star_u_star)
     #
     dpd = flex.complex_double(flex.grid(np,1), 0j)
     def paste(d, i):
       d.reshape(flex.grid(d.size(),1))
       dpd.matrix_paste_block_in_place(d, i,0)
     paste(d2_site_site.matrix_packed_u_diagonal(), 0)
     if (not scatterer.flags.use_u_aniso()):
       dpd[i_u] = d2_u_iso_u_iso
     else:
       paste(d2_u_star_u_star.matrix_packed_u_diagonal(), i_u)
     yield dpd
Exemple #54
0
    def d2f_d_params_diag(self):
        tphkl = 2 * math.pi * flex.double(self.hkl)
        tphkl_outer = tphkl.matrix_outer_product(tphkl) \
          .matrix_symmetric_as_packed_u()
        h, k, l = self.hkl
        d_exp_huh_d_u_star = flex.double(
            [h**2, k**2, l**2, 2 * h * k, 2 * h * l, 2 * k * l])
        d2_exp_huh_d_u_star_u_star = d_exp_huh_d_u_star.matrix_outer_product(
            d_exp_huh_d_u_star).matrix_symmetric_as_packed_u()
        for i_scatterer, scatterer in enumerate(self.scatterers):
            site_symmetry_ops = None
            if (self.site_symmetry_table.is_special_position(i_scatterer)):
                site_symmetry_ops = self.site_symmetry_table.get(i_scatterer)
                site_constraints = site_symmetry_ops.site_constraints()
                if (scatterer.flags.use_u_aniso()):
                    adp_constraints = site_symmetry_ops.adp_constraints()
            w = scatterer.weight()
            if (not scatterer.flags.use_u_aniso()):
                huh = scatterer.u_iso * self.d_star_sq
                dw = math.exp(mtps * huh)
            gaussian = self.scattering_type_registry.gaussian_not_optional(
                scattering_type=scatterer.scattering_type)
            f0 = gaussian.at_d_star_sq(self.d_star_sq)
            ffp = f0 + scatterer.fp
            fdp = scatterer.fdp
            ff = (ffp + 1j * fdp)
            d2_site_site = flex.complex_double(3 * (3 + 1) // 2, 0j)
            if (not scatterer.flags.use_u_aniso()):
                d2_u_iso_u_iso = 0j
            else:
                d2_u_star_u_star = flex.complex_double(6 * (6 + 1) // 2, 0j)
            for s in self.space_group:
                r = s.r().as_rational().as_float()
                s_site = s * scatterer.site
                alpha = tphkl.dot(flex.double(s_site))
                if (scatterer.flags.use_u_aniso()):
                    s_u_star_s = r * matrix.sym(
                        sym_mat3=scatterer.u_star) * r.transpose()
                    huh = (matrix.row(self.hkl) * s_u_star_s).dot(
                        matrix.col(self.hkl))
                    dw = math.exp(mtps * huh)
                e = cmath.exp(1j * alpha)
                site_gtmx = flex.double(r.transpose())
                site_gtmx.reshape(flex.grid(3, 3))
                d2_site_site += (w * dw * ff * e * (-1)) * (
                    site_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
                        tphkl_outer))
                if (not scatterer.flags.use_u_aniso()):
                    d2_u_iso_u_iso += w * dw * ff * e * (mtps *
                                                         self.d_star_sq)**2
                else:
                    u_star_gtmx = tensor_rank_2_gradient_transform_matrix(r)
                    d2_u_star_u_star +=(w * dw * ff * e * mtps**2) \
                      * u_star_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
                          d2_exp_huh_d_u_star_u_star)
            if (site_symmetry_ops is None):
                i_u = 3
            else:
                i_u = site_constraints.n_independent_params()
            if (not scatterer.flags.use_u_aniso()):
                i_occ = i_u + 1
            elif (site_symmetry_ops is None):
                i_occ = i_u + 6
            else:
                i_occ = i_u + adp_constraints.n_independent_params()
            np = i_occ + 3
            if (site_symmetry_ops is not None):
                gsm = site_constraints.gradient_sum_matrix()
                d2_site_site = gsm.matrix_multiply_packed_u_multiply_lhs_transpose(
                    packed_u=d2_site_site)
                if (scatterer.flags.use_u_aniso()):
                    gsm = adp_constraints.gradient_sum_matrix()
                    d2_u_star_u_star = gsm \
                      .matrix_multiply_packed_u_multiply_lhs_transpose(
                        packed_u=d2_u_star_u_star)
            #
            dpd = flex.complex_double(flex.grid(np, 1), 0j)

            def paste(d, i):
                d.reshape(flex.grid(d.size(), 1))
                dpd.matrix_paste_block_in_place(d, i, 0)

            paste(d2_site_site.matrix_packed_u_diagonal(), 0)
            if (not scatterer.flags.use_u_aniso()):
                dpd[i_u] = d2_u_iso_u_iso
            else:
                paste(d2_u_star_u_star.matrix_packed_u_diagonal(), i_u)
            yield dpd
 def df_d_params(self):
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   h,k,l = self.hkl
   d_exp_huh_d_u_star = matrix.col([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   for i_scatterer,scatterer in enumerate(self.scatterers):
     site_symmetry_ops = None
     if (self.site_symmetry_table.is_special_position(i_scatterer)):
       site_symmetry_ops = self.site_symmetry_table.get(i_scatterer)
       site_constraints = site_symmetry_ops.site_constraints()
       if (scatterer.flags.use_u_aniso()):
         adp_constraints = site_symmetry_ops.adp_constraints()
     w = scatterer.weight()
     wwo = scatterer.weight_without_occupancy()
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     gaussian = self.scattering_type_registry.gaussian_not_optional(
       scattering_type=scatterer.scattering_type)
     f0 = gaussian.at_d_star_sq(self.d_star_sq)
     ffp = f0 + scatterer.fp
     fdp = scatterer.fdp
     ff = ffp + 1j * fdp
     d_site = matrix.col([0,0,0])
     if (not scatterer.flags.use_u_aniso()):
       d_u_iso = 0
       d_u_star = None
     else:
       d_u_iso = None
       d_u_star = matrix.col([0,0,0,0,0,0])
     d_occ = 0j
     d_fp = 0j
     d_fdp = 0j
     for s in self.space_group:
       r = s.r().as_rational().as_float()
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       site_gtmx = r.transpose()
       d_site += site_gtmx * (
         w * dw * ff * e * 1j * tphkl)
       if (not scatterer.flags.use_u_aniso()):
         d_u_iso += w * dw * ff * e * mtps * self.d_star_sq
       else:
         u_star_gtmx = matrix.sqr(tensor_rank_2_gradient_transform_matrix(r))
         d_u_star += u_star_gtmx * (
           w * dw * ff * e * mtps * d_exp_huh_d_u_star)
       d_occ += wwo * dw * ff * e
       d_fp += w * dw * e
       d_fdp += w * dw * e * 1j
     if (site_symmetry_ops is not None):
       gsm = site_constraints.gradient_sum_matrix()
       gsm = matrix.rec(elems=gsm, n=gsm.focus())
       d_site = gsm * d_site
       if (scatterer.flags.use_u_aniso()):
         gsm = adp_constraints.gradient_sum_matrix()
         gsm = matrix.rec(elems=gsm, n=gsm.focus())
         d_u_star = gsm * d_u_star
     result = flex.complex_double(d_site)
     if (not scatterer.flags.use_u_aniso()):
       result.append(d_u_iso)
     else:
       result.extend(flex.complex_double(d_u_star))
     result.extend(flex.complex_double([d_occ, d_fp, d_fdp]))
     yield result
 def d2f_d_params(self):
   tphkl = 2 * math.pi * matrix.col(self.hkl)
   tphkl_outer = tphkl.outer_product()
   h,k,l = self.hkl
   d_exp_huh_d_u_star = matrix.col([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   d2_exp_huh_d_u_star_u_star = d_exp_huh_d_u_star.outer_product()
   for scatterer in self.scatterers:
     assert scatterer.scattering_type == "const"
     w = scatterer.occupancy
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     ffp = 1 + scatterer.fp
     fdp = scatterer.fdp
     ff = (ffp + 1j * fdp)
     d2_site_site = flex.complex_double(flex.grid(3,3), 0j)
     if (not scatterer.flags.use_u_aniso()):
       d2_site_u_iso = flex.complex_double(flex.grid(3,1), 0j)
       d2_site_u_star = None
     else:
       d2_site_u_iso = None
       d2_site_u_star = flex.complex_double(flex.grid(3,6), 0j)
     d2_site_occ = flex.complex_double(flex.grid(3,1), 0j)
     d2_site_fp = flex.complex_double(flex.grid(3,1), 0j)
     d2_site_fdp = flex.complex_double(flex.grid(3,1), 0j)
     if (not scatterer.flags.use_u_aniso()):
       d2_u_iso_u_iso = 0j
       d2_u_iso_occ = 0j
       d2_u_iso_fp = 0j
       d2_u_iso_fdp = 0j
     else:
       d2_u_star_u_star = flex.complex_double(flex.grid(6,6), 0j)
       d2_u_star_occ = flex.complex_double(flex.grid(6,1), 0j)
       d2_u_star_fp = flex.complex_double(flex.grid(6,1), 0j)
       d2_u_star_fdp = flex.complex_double(flex.grid(6,1), 0j)
     d2_occ_fp = 0j
     d2_occ_fdp = 0j
     for s in self.space_group:
       r = s.r().as_rational().as_float()
       s_site = s * scatterer.site
       alpha = matrix.col(s_site).dot(tphkl)
       if (scatterer.flags.use_u_aniso()):
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       site_gtmx = r.transpose()
       d2_site_site += flex.complex_double(
         site_gtmx *
           (w * dw * ff * e * (-1) * tphkl_outer)
              * site_gtmx.transpose())
       if (not scatterer.flags.use_u_aniso()):
         d2_site_u_iso += flex.complex_double(site_gtmx * (
           w * dw * ff * e * 1j * mtps * self.d_star_sq * tphkl))
       else:
         u_star_gtmx = matrix.sqr(tensor_rank_2_gradient_transform_matrix(r))
         d2_site_u_star += flex.complex_double(
             site_gtmx
           * ((w * dw * ff * e * 1j * tphkl).outer_product(
               mtps * d_exp_huh_d_u_star))
           * u_star_gtmx.transpose())
       d2_site_occ += flex.complex_double(site_gtmx * (
         dw * ff * e * 1j * tphkl))
       d2_site_fp += flex.complex_double(site_gtmx * (
         w * dw * e * 1j * tphkl))
       d2_site_fdp += flex.complex_double(site_gtmx * (
         w * dw * e * (-1) * tphkl))
       if (not scatterer.flags.use_u_aniso()):
         d2_u_iso_u_iso += w * dw * ff * e * (mtps * self.d_star_sq)**2
         d2_u_iso_occ += dw * ff * e * mtps * self.d_star_sq
         d2_u_iso_fp += w * dw * e * mtps * self.d_star_sq
         d2_u_iso_fdp += 1j * w * dw * e * mtps * self.d_star_sq
       else:
         d2_u_star_u_star += flex.complex_double(
             u_star_gtmx
           * (w * dw * ff * e * mtps**2 * d2_exp_huh_d_u_star_u_star)
           * u_star_gtmx.transpose())
         d2_u_star_occ += flex.complex_double(u_star_gtmx * (
           dw * ff * e * mtps * d_exp_huh_d_u_star))
         d2_u_star_fp += flex.complex_double(u_star_gtmx * (
           w * dw * e * mtps * d_exp_huh_d_u_star))
         d2_u_star_fdp += flex.complex_double(u_star_gtmx * (
           w * dw * 1j * e * mtps * d_exp_huh_d_u_star))
       d2_occ_fp += dw * e
       d2_occ_fdp += dw * e * 1j
     if (not scatterer.flags.use_u_aniso()):
       i_occ, i_fp, i_fdp, np = 4, 5, 6, 7
     else:
       i_occ, i_fp, i_fdp, np = 9, 10, 11, 12
     dp = flex.complex_double(flex.grid(np,np), 0j)
     paste = dp.matrix_paste_block_in_place
     paste(d2_site_site, 0,0)
     if (not scatterer.flags.use_u_aniso()):
       paste(d2_site_u_iso, 0,3)
       paste(d2_site_u_iso.matrix_transpose(), 3,0)
     else:
       paste(d2_site_u_star, 0,3)
       paste(d2_site_u_star.matrix_transpose(), 3,0)
     paste(d2_site_occ, 0,i_occ)
     paste(d2_site_occ.matrix_transpose(), i_occ,0)
     paste(d2_site_fp, 0,i_fp)
     paste(d2_site_fp.matrix_transpose(), i_fp,0)
     paste(d2_site_fdp, 0,i_fdp)
     paste(d2_site_fdp.matrix_transpose(), i_fdp,0)
     if (not scatterer.flags.use_u_aniso()):
       dp[3*7+3] = d2_u_iso_u_iso
       dp[3*7+4] = d2_u_iso_occ
       dp[4*7+3] = d2_u_iso_occ
       dp[3*7+5] = d2_u_iso_fp
       dp[5*7+3] = d2_u_iso_fp
       dp[3*7+6] = d2_u_iso_fdp
       dp[6*7+3] = d2_u_iso_fdp
     else:
       paste(d2_u_star_u_star, 3,3)
       paste(d2_u_star_occ, 3, 9)
       paste(d2_u_star_occ.matrix_transpose(), 9, 3)
       paste(d2_u_star_fp, 3, 10)
       paste(d2_u_star_fp.matrix_transpose(), 10, 3)
       paste(d2_u_star_fdp, 3, 11)
       paste(d2_u_star_fdp.matrix_transpose(), 11, 3)
     dp[i_occ*np+i_fp] = d2_occ_fp
     dp[i_fp*np+i_occ] = d2_occ_fp
     dp[i_occ*np+i_fdp] = d2_occ_fdp
     dp[i_fdp*np+i_occ] = d2_occ_fdp
     yield dp
 def d2f_d_params(self):
   tphkl = 2 * math.pi * flex.double(self.hkl)
   tphkl_outer = tphkl.matrix_outer_product(tphkl) \
     .matrix_symmetric_as_packed_u()
   h,k,l = self.hkl
   d_exp_huh_d_u_star = flex.double([h**2, k**2, l**2, 2*h*k, 2*h*l, 2*k*l])
   d2_exp_huh_d_u_star_u_star = d_exp_huh_d_u_star.matrix_outer_product(
     d_exp_huh_d_u_star).matrix_symmetric_as_packed_u()
   for i_scatterer,scatterer in enumerate(self.scatterers):
     site_symmetry_ops = None
     if (self.site_symmetry_table.is_special_position(i_scatterer)):
       site_symmetry_ops = self.site_symmetry_table.get(i_scatterer)
       site_constraints = site_symmetry_ops.site_constraints()
       if (scatterer.flags.use_u_aniso()):
         adp_constraints = site_symmetry_ops.adp_constraints()
     w = scatterer.weight()
     wwo = scatterer.weight_without_occupancy()
     if (not scatterer.flags.use_u_aniso()):
       huh = scatterer.u_iso * self.d_star_sq
       dw = math.exp(mtps * huh)
     gaussian = self.scattering_type_registry.gaussian_not_optional(
       scattering_type=scatterer.scattering_type)
     f0 = gaussian.at_d_star_sq(self.d_star_sq)
     ffp = f0 + scatterer.fp
     fdp = scatterer.fdp
     ff = (ffp + 1j * fdp)
     d2_site_site = flex.complex_double(3*(3+1)//2, 0j)
     if (not scatterer.flags.use_u_aniso()):
       d2_site_u_iso = flex.complex_double(flex.grid(3,1), 0j)
       d2_site_u_star = None
     else:
       d2_site_u_iso = None
       d2_site_u_star = flex.complex_double(flex.grid(3,6), 0j)
     d2_site_occ = flex.complex_double(flex.grid(3,1), 0j)
     d2_site_fp = flex.complex_double(flex.grid(3,1), 0j)
     d2_site_fdp = flex.complex_double(flex.grid(3,1), 0j)
     if (not scatterer.flags.use_u_aniso()):
       d2_u_iso_u_iso = 0j
       d2_u_iso_occ = 0j
       d2_u_iso_fp = 0j
       d2_u_iso_fdp = 0j
     else:
       d2_u_star_u_star = flex.complex_double(6*(6+1)//2, 0j)
       d2_u_star_occ = flex.complex_double(flex.grid(6,1), 0j)
       d2_u_star_fp = flex.complex_double(flex.grid(6,1), 0j)
       d2_u_star_fdp = flex.complex_double(flex.grid(6,1), 0j)
     d2_occ_fp = 0j
     d2_occ_fdp = 0j
     for s in self.space_group:
       r = s.r().as_rational().as_float()
       s_site = s * scatterer.site
       alpha = tphkl.dot(flex.double(s_site))
       if (scatterer.flags.use_u_aniso()):
         s_u_star_s = r*matrix.sym(sym_mat3=scatterer.u_star)*r.transpose()
         huh = (matrix.row(self.hkl) * s_u_star_s).dot(matrix.col(self.hkl))
         dw = math.exp(mtps * huh)
       e = cmath.exp(1j*alpha)
       site_gtmx = flex.double(r.transpose())
       site_gtmx.reshape(flex.grid(3,3))
       d2_site_site += (w * dw * ff * e * (-1)) * (
         site_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
           tphkl_outer))
       if (not scatterer.flags.use_u_aniso()):
         d2_site_u_iso += (w * dw * ff * e * 1j * mtps * self.d_star_sq) \
           * site_gtmx.matrix_multiply(tphkl)
       else:
         u_star_gtmx = tensor_rank_2_gradient_transform_matrix(r)
         d2_site_u_star += (w * dw * ff * e * 1j * mtps) \
           * site_gtmx.matrix_multiply(
               tphkl.matrix_outer_product(d_exp_huh_d_u_star)) \
                 .matrix_multiply(u_star_gtmx.matrix_transpose())
       site_gtmx_tphkl = site_gtmx.matrix_multiply(tphkl)
       d2_site_occ += (wwo * dw * ff * e * 1j) * site_gtmx_tphkl
       d2_site_fp += (w * dw * e * 1j) * site_gtmx_tphkl
       d2_site_fdp += (w * dw * e * (-1)) * site_gtmx_tphkl
       if (not scatterer.flags.use_u_aniso()):
         d2_u_iso_u_iso += w * dw * ff * e * (mtps * self.d_star_sq)**2
         d2_u_iso_occ += wwo * dw * ff * e * mtps * self.d_star_sq
         d2_u_iso_fp += w * dw * e * mtps * self.d_star_sq
         d2_u_iso_fdp += 1j * w * dw * e * mtps * self.d_star_sq
       else:
         d2_u_star_u_star +=(w * dw * ff * e * mtps**2) \
           * u_star_gtmx.matrix_multiply_packed_u_multiply_lhs_transpose(
               d2_exp_huh_d_u_star_u_star)
         u_star_gtmx_d_exp_huh_d_u_star = u_star_gtmx.matrix_multiply(
           d_exp_huh_d_u_star)
         d2_u_star_occ += (wwo * dw * ff * e * mtps) \
           * u_star_gtmx_d_exp_huh_d_u_star
         d2_u_star_fp += (w * dw * e * mtps) \
           * u_star_gtmx_d_exp_huh_d_u_star
         d2_u_star_fdp += (w * dw * 1j * e * mtps) \
           * u_star_gtmx_d_exp_huh_d_u_star
       d2_occ_fp += wwo * dw * e
       d2_occ_fdp += wwo * dw * e * 1j
     if (site_symmetry_ops is None):
       i_u = 3
     else:
       i_u = site_constraints.n_independent_params()
     if (not scatterer.flags.use_u_aniso()):
       i_occ = i_u + 1
     elif (site_symmetry_ops is None):
       i_occ = i_u + 6
     else:
       i_occ = i_u + adp_constraints.n_independent_params()
     i_fp, i_fdp, np = i_occ+1, i_occ+2, i_occ+3
     if (site_symmetry_ops is not None):
       gsm = site_constraints.gradient_sum_matrix()
       d2_site_site = gsm.matrix_multiply_packed_u_multiply_lhs_transpose(
         packed_u=d2_site_site)
       if (not scatterer.flags.use_u_aniso()):
         d2_site_u_iso = gsm.matrix_multiply(d2_site_u_iso)
       else:
         d2_site_u_star = gsm.matrix_multiply(d2_site_u_star)
       d2_site_occ = gsm.matrix_multiply(d2_site_occ)
       d2_site_fp = gsm.matrix_multiply(d2_site_fp)
       d2_site_fdp = gsm.matrix_multiply(d2_site_fdp)
       if (scatterer.flags.use_u_aniso()):
         gsm = adp_constraints.gradient_sum_matrix()
         d2_site_u_star = d2_site_u_star.matrix_multiply(
           gsm.matrix_transpose())
         d2_u_star_u_star = gsm \
           .matrix_multiply_packed_u_multiply_lhs_transpose(
             packed_u=d2_u_star_u_star)
         d2_u_star_occ = gsm.matrix_multiply(d2_u_star_occ)
         d2_u_star_fp = gsm.matrix_multiply(d2_u_star_fp)
         d2_u_star_fdp = gsm.matrix_multiply(d2_u_star_fdp)
     dp = flex.complex_double(flex.grid(np,np), 0j)
     paste = dp.matrix_paste_block_in_place
     paste(d2_site_site.matrix_packed_u_as_symmetric(), 0,0)
     if (not scatterer.flags.use_u_aniso()):
       paste(d2_site_u_iso, 0,i_u)
       paste(d2_site_u_iso.matrix_transpose(), i_u,0)
     else:
       paste(d2_site_u_star, 0,i_u)
       paste(d2_site_u_star.matrix_transpose(), i_u,0)
     paste(d2_site_occ, 0,i_occ)
     paste(d2_site_occ.matrix_transpose(), i_occ,0)
     paste(d2_site_fp, 0,i_fp)
     paste(d2_site_fp.matrix_transpose(), i_fp,0)
     paste(d2_site_fdp, 0,i_fdp)
     paste(d2_site_fdp.matrix_transpose(), i_fdp,0)
     if (not scatterer.flags.use_u_aniso()):
       dp[i_u*np+i_u] = d2_u_iso_u_iso
       dp[i_u*np+i_occ] = d2_u_iso_occ
       dp[i_occ*np+i_u] = d2_u_iso_occ
       dp[i_u*np+i_fp] = d2_u_iso_fp
       dp[i_fp*np+i_u] = d2_u_iso_fp
       dp[i_u*np+i_fdp] = d2_u_iso_fdp
       dp[i_fdp*np+i_u] = d2_u_iso_fdp
     else:
       paste(d2_u_star_u_star.matrix_packed_u_as_symmetric(), i_u, i_u)
       paste(d2_u_star_occ, i_u, i_occ)
       paste(d2_u_star_occ.matrix_transpose(), i_occ, i_u)
       paste(d2_u_star_fp, i_u, i_fp)
       paste(d2_u_star_fp.matrix_transpose(), i_fp, i_u)
       paste(d2_u_star_fdp, i_u, i_fdp)
       paste(d2_u_star_fdp.matrix_transpose(), i_fdp, i_u)
     dp[i_occ*np+i_fp] = d2_occ_fp
     dp[i_fp*np+i_occ] = d2_occ_fp
     dp[i_occ*np+i_fdp] = d2_occ_fdp
     dp[i_fdp*np+i_occ] = d2_occ_fdp
     yield dp
Exemple #58
0
    def __init__(self,
                 xray_structure,
                 covariance_matrix=None,
                 cell_covariance_matrix=None):
        crystal_symmetry_as_cif_block.__init__(
            self,
            xray_structure.crystal_symmetry(),
            cell_covariance_matrix=cell_covariance_matrix)
        scatterers = xray_structure.scatterers()
        uc = xray_structure.unit_cell()
        if covariance_matrix is not None:
            param_map = xray_structure.parameter_map()
            covariance_diagonal = covariance_matrix.matrix_packed_u_diagonal()
            u_star_to_u_cif_linear_map_pow2 = flex.pow2(
                flex.double(uc.u_star_to_u_cif_linear_map()))
            u_star_to_u_iso_linear_form = matrix.row(
                uc.u_star_to_u_iso_linear_form())
        fmt = "%.6f"

        # _atom_site_* loop
        atom_site_loop = model.loop(
            header=('_atom_site_label', '_atom_site_type_symbol',
                    '_atom_site_fract_x', '_atom_site_fract_y',
                    '_atom_site_fract_z', '_atom_site_U_iso_or_equiv',
                    '_atom_site_adp_type', '_atom_site_occupancy'))
        for i_seq, sc in enumerate(scatterers):
            # site
            if covariance_matrix is not None and sc.flags.grad_site():
                site = []
                for i in range(3):
                    idx = param_map[i_seq].site
                    if idx > -1:
                        var = covariance_diagonal[idx + i]
                    else:
                        var = 0
                    if var > 0:
                        site.append(
                            format_float_with_su(sc.site[i], math.sqrt(var)))
                    else:
                        site.append(fmt % sc.site[i])
            else:
                site = [fmt % sc.site[i] for i in range(3)]
            # u_eq
            if (covariance_matrix is not None
                    and (sc.flags.grad_u_iso() or sc.flags.grad_u_aniso())):
                if sc.flags.grad_u_iso():
                    u_iso_or_equiv = format_float_with_su(
                        sc.u_iso,
                        math.sqrt(
                            covariance.variance_for_u_iso(
                                i_seq, covariance_matrix, param_map)))
                else:
                    cov = covariance.extract_covariance_matrix_for_u_aniso(
                        i_seq, covariance_matrix,
                        param_map).matrix_packed_u_as_symmetric()
                    var = (u_star_to_u_iso_linear_form *
                           matrix.sqr(cov)).dot(u_star_to_u_iso_linear_form)
                    u_iso_or_equiv = format_float_with_su(
                        sc.u_iso_or_equiv(uc), math.sqrt(var))
            else:
                u_iso_or_equiv = fmt % sc.u_iso_or_equiv(uc)
            if sc.flags.use_u_aniso():
                adp_type = 'Uani'
            else:
                adp_type = 'Uiso'
            atom_site_loop.add_row(
                (sc.label, sc.scattering_type, site[0], site[1], site[2],
                 u_iso_or_equiv, adp_type, fmt % sc.occupancy))
        self.cif_block.add_loop(atom_site_loop)

        # _atom_site_aniso_* loop
        aniso_scatterers = scatterers.select(scatterers.extract_use_u_aniso())
        if aniso_scatterers.size():
            labels = list(scatterers.extract_labels())
            aniso_loop = model.loop(
                header=('_atom_site_aniso_label', '_atom_site_aniso_U_11',
                        '_atom_site_aniso_U_22', '_atom_site_aniso_U_33',
                        '_atom_site_aniso_U_12', '_atom_site_aniso_U_13',
                        '_atom_site_aniso_U_23'))
            for sc in aniso_scatterers:
                u_cif = adptbx.u_star_as_u_cif(uc, sc.u_star)
                if covariance_matrix is not None:
                    row = [sc.label]
                    idx = param_map[labels.index(sc.label)].u_aniso
                    if idx > -1:
                        var = covariance_diagonal[
                            idx:idx + 6] * u_star_to_u_cif_linear_map_pow2
                        for i in range(6):
                            if var[i] > 0:
                                row.append(
                                    format_float_with_su(
                                        u_cif[i], math.sqrt(var[i])))
                            else:
                                row.append(fmt % u_cif[i])
                    else:
                        row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
                else:
                    row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
                aniso_loop.add_row(row)
            self.cif_block.add_loop(aniso_loop)
            self.cif_block.add_loop(atom_type_cif_loop(xray_structure))