Beispiel #1
0
def drizzle_test(sbox, beam_vectors, angles, experiment):
    from dials.algorithms.reflection_basis import CoordinateSystem

    # from dials.algorithms.image.drizzle import drizzle

    beam = experiment.beam
    detector = experiment.detector
    goniometer = experiment.goniometer
    scan = experiment.scan

    s0 = beam.get_s0()
    m2 = goniometer.get_rotation_axis()

    s1 = beam_vectors[0]
    phi = angles[0]
    cs_target = CoordinateSystem(m2, s0, s1, phi)
    from matplotlib import pylab

    fig = pylab.figure()
    ax = fig.gca()
    colour = ["black", "blue", "red", "green", "yellow", "cyan", "magenta"]
    output = flex.double(flex.grid(sbox[0].data.all()))
    for r in range(len(sbox)):
        s1 = beam_vectors[r]
        phi = angles[r]
        cs = CoordinateSystem(m2, s0, s1, phi)
        e = rs_coords(sbox[r].bbox, cs, beam, detector, scan)
        e1, e2, e3 = e.parts()
        p = px_coords(e, cs_target, detector, scan)
        x, y, z = p.parts()
        pylab.scatter(x, y, color=colour[r])
        input = sbox[r].data.all()
        x -= sbox[0].bbox[0]
        y -= sbox[0].bbox[2]
        z -= sbox[0].bbox[4]
        # coords = flex.vec3_double(x, y, z)
        # drizzle(output, input, coords)

    ax.set_xticks(range(sbox[0].bbox[0], sbox[0].bbox[1] + 1))
    ax.set_yticks(range(sbox[0].bbox[2], sbox[0].bbox[3] + 1))
    pylab.grid()
    pylab.show()
Beispiel #2
0
def test_transform(
    experiment, shoebox, s1, phi, grid_size, sigma_m, sigma_b, n_sigma, ndiv=5
):
    from dials.algorithms.reflection_basis.transform import MapFramesForward
    from dials.algorithms.reflection_basis import CoordinateSystem

    bbox = shoebox.bbox
    data = shoebox.data
    mask = shoebox.mask
    x0, x1, y0, y1, z0, z1 = bbox

    step_size = (
        n_sigma * sigma_m / (grid_size + 0.5),
        n_sigma * sigma_b / (grid_size + 0.5),
        n_sigma * sigma_b / (grid_size + 0.5),
    )

    grid_range = 2 * grid_size + 1
    offset = grid_size + 0.5
    grid = flex.double(flex.grid(grid_range, grid_range, grid_range))

    m2 = experiment.goniometer.get_rotation_axis()
    s0 = experiment.beam.get_s0()
    cs = CoordinateSystem(m2, s0, s1, phi)

    grid_index = GridIndex(experiment, cs, offset, step_size)

    # phi0, dphi = experiment.scan.get_oscillation(deg=False)
    # map_frames = MapFramesForward(phi0, dphi, sigma_m, n_sigma, grid_size)
    # zfraction = map_frames((z0, z1), phi, cs.zeta())

    # for j in range(zfraction.all()[0]):
    # print ' '.join(str(zfraction[j,i]) for i in range(zfraction.all()[1]))

    # for j in range(zfraction.all()[0]):
    # print "Fraction %d: %f" % (j, flex.sum(zfraction[j:j+1,:]))

    fraction = 1.0 / (ndiv * ndiv * ndiv)
    for k in range(data.all()[0]):
        for j in range(data.all()[1]):
            for i in range(data.all()[2]):
                if mask[k, j, i]:
                    value = data[k, j, i] * fraction
                    for kk in range(0, ndiv):
                        for jj in range(0, ndiv):
                            for ii in range(0, ndiv):
                                kkk = z0 + k + 1.0 * (kk + 0.5) / ndiv
                                jjj = y0 + j + 1.0 * (jj + 0.5) / ndiv
                                iii = x0 + i + 1.0 * (ii + 0.5) / ndiv
                                gk, gj, gi = grid_index(kkk, jjj, iii)
                                if (
                                    gk >= 0
                                    and gk < grid_range
                                    and gj >= 0
                                    and gj < grid_range
                                    and gi >= 0
                                    and gi < grid_range
                                ):
                                    grid[gk, gj, gi] += value

    # fraction = 1.0 / (ndiv * ndiv)
    # for k in range(data.all()[0]):
    # for j in range(data.all()[1]):
    # for i in range(data.all()[2]):
    # if mask[k,j,i]:
    # value = data[k,j,i] * fraction
    # for jj in range(0, ndiv):
    # for ii in range(0, ndiv):
    # jjj = y0 + j + 1.0 * (jj + 0.5) / ndiv
    # iii = x0 + i + 1.0 * (ii + 0.5) / ndiv
    # gj, gi = grid_index(jjj,iii)
    # if (gj >= 0 and gj < grid_range and
    # gi >= 0 and gi < grid_range):
    # for gk in range(0, 2*grid_size+1):
    # grid[gk,gj,gi] += value * zfraction[k,gk]

    return grid
Beispiel #3
0
div = 4
mask1 = flex.bool(flex.grid(int(ysize / div), int(xsize / div)))
mask2 = flex.bool(flex.grid(int(ysize / div), int(xsize / div)))

n = 5
dm = n * 0.157 * pi / 180.0
# dm = n * 1.0 * pi / 180.0

# dm /= pi / 2

print(dm)

xyz = detector.get_pixel_lab_coord((0, 1200))
s1 = matrix.col(xyz).normalize() * s0.length()
phi = 0.0
cs = CoordinateSystem(m2, s0, s1, phi)
print("Limits: ", cs.limits())

# from_angle = FromRotationAngleAccurate(cs)
# phi_list = []
# e3_list = []
# for t in range(-100, 100):
#    p = phi - dm * t / 10
#    print p, from_angle(p)
#    phi_list.append(p)
#    e3_list.append(from_angle(p))

# from matplotlib import pylab
# pylab.plot(phi_list, e3_list)
# pylab.axvline(x=phi)
# pylab.show()
Beispiel #4
0
from dials.algorithms.reflection_basis import ToRotationAngleAccurate
from dials.algorithms.reflection_basis import FromRotationAngleFast

# s0 = matrix.col((0.00801639379479156, -3.8514801707506e-14, -1.0208975723528189) )
# m2 = matrix.col((1.0, -1.5919306617286774e-16, -6.904199434387693e-16))
# s1 = matrix.col((0.502248600762, -0.0181543707198, -0.888657908118))

# s0 = matrix.col((0.0, 0.0, -1.0))
# m2 = matrix.col((1.0, 0.0, 0.0))
# s1 = matrix.col((1.0, 0.05, 0.0)).normalize()
phi = 0

# c3 = -0.013439
n = 5
c3 = -n * 0.157 * pi / 180.0
cs = CoordinateSystem(m2, s0, s1, phi)
print(cs.zeta())
# e1 = matrix.col(cs.e1_axis())
# e3 = matrix.col(cs.e3_axis())
# ps = matrix.col(cs.p_star())

# from math import sqrt
# m2e1 = m2.dot(e1)
# m2e3 = m2.dot(e3)
# m2ps = m2.dot(ps.normalize())

# print tuple(e1)
# print tuple(e3)
# print tuple(ps)
# print "m2.e1", m2e1
# print "m2.e3", m2e3
Beispiel #5
0
div = 4
mask1 = flex.bool(flex.grid(int(ysize / div), int(xsize / div)))
mask2 = flex.bool(flex.grid(int(ysize / div), int(xsize / div)))

n = 5
dm = n * 0.157 * pi / 180.0
#dm = n * 1.0 * pi / 180.0

#dm /= pi / 2

print dm

xyz = detector.get_pixel_lab_coord((0, 1200))
s1 = matrix.col(xyz).normalize() * s0.length()
phi = 0.0
cs = CoordinateSystem(m2, s0, s1, phi)
print "Limits: ", cs.limits()

#from_angle = FromRotationAngleAccurate(cs)
#phi_list = []
#e3_list = []
#for t in range(-100, 100):
#    p = phi - dm * t / 10
#    print p, from_angle(p)
#    phi_list.append(p)
#    e3_list.append(from_angle(p))

#from matplotlib import pylab
#pylab.plot(phi_list, e3_list)
#pylab.axvline(x=phi)
#pylab.show()
Beispiel #6
0
from dials.algorithms.reflection_basis import ToRotationAngleAccurate
from dials.algorithms.reflection_basis import FromRotationAngleFast

#s0 = matrix.col((0.00801639379479156, -3.8514801707506e-14, -1.0208975723528189) )
#m2 = matrix.col((1.0, -1.5919306617286774e-16, -6.904199434387693e-16))
#s1 = matrix.col((0.502248600762, -0.0181543707198, -0.888657908118))

#s0 = matrix.col((0.0, 0.0, -1.0))
#m2 = matrix.col((1.0, 0.0, 0.0))
#s1 = matrix.col((1.0, 0.05, 0.0)).normalize()
phi =  0

#c3 = -0.013439
n = 5
c3 = -n * 0.157 * pi / 180.0
cs = CoordinateSystem(m2, s0, s1, phi)
print cs.zeta()
#e1 = matrix.col(cs.e1_axis())
#e3 = matrix.col(cs.e3_axis())
#ps = matrix.col(cs.p_star())

#from math import sqrt
#m2e1 = m2.dot(e1)
#m2e3 = m2.dot(e3)
#m2ps = m2.dot(ps.normalize())

#print tuple(e1)
#print tuple(e3)
#print tuple(ps)
#print "m2.e1", m2e1
#print "m2.e3", m2e3