def extract_estimated_i_obs(O, partiality_threshold):
from cctbx.array_family import flex
indices = flex.miller_index()
data = flex.double()
mimmi = O.miller_image_map.miller_indices
indices.reserve(mimmi.size())
data.reserve(mimmi.size())
for h,iiis in zip(mimmi, O.miller_image_map.map):
estis = collect_estis(O.array, iiis, partiality_threshold)
if (estis.size() != 0):
indices.append(h)
data.append(flex.mean(estis))
return (indices, data)
def extract_estimated_i_obs(O, partiality_threshold):
from cctbx.array_family import flex
indices = flex.miller_index()
data = flex.double()
mimmi = O.miller_image_map.miller_indices
indices.reserve(mimmi.size())
data.reserve(mimmi.size())
for h,iiis in zip(mimmi, O.miller_image_map.map):
estis = collect_estis(O.array, iiis, partiality_threshold)
if (estis.size() != 0):
indices.append(h)
data.append(flex.mean(estis))
return (indices, data)
def load_sfall(fname, data_are_complex=True):
"""
special script for loading the structure factor file generated in write_multichannel_sfall()
:param fname: file generated in the write_multichannel_sfall method above..
:return: mil_ar, energies
mil_ar: dict of miller arrays
energies: array of xray energies in electron volts
such that mil_ar[0] is Fhkl at energy energies[0]
"""
f = h5py.File(fname, "r")
data = f["data"][()]
indices_data = f["indices"][()]
indices_for_flex = [] # make a list for flex constructor
for hkl in indices_data:
h, k, l = list(map(int, hkl)) # cast to python int for Python 3
indices_for_flex.append((h, k, l))
hall = f["hall_symbol"][()]
ucell_param = tuple(f["ucell_tuple"][()])
energies = f["energies"][()]
sg = sgtbx.space_group(hall)
Symm = crystal.symmetry(unit_cell=ucell_param, space_group=sg)
#indices_flex = tuple(map(tuple, indices))
mil_idx = flex.miller_index(indices_for_flex)
mil_set = miller.set(crystal_symmetry=Symm,
indices=mil_idx,
anomalous_flag=True)
mil_ar = {} # load a dict of "sfall at each energy"
for i_chan, data_chan in enumerate(data):
if data_are_complex:
data_flex = flex.complex_double(np.ascontiguousarray(data_chan))
else:
data_flex = flex.double(np.ascontiguousarray(data_chan))
mil_ar[i_chan] = miller.array(mil_set, data=data_flex)
return mil_ar, energies
def offset_miller_indices(miller_indices, offset):
from dials.array_family import flex
return flex.miller_index(*[
mi.iround()
for mi in (miller_indices.as_vec3_double() + offset).parts()
])
def offset_miller_indices(miller_indices, offset):
from dials.array_family import flex
return flex.miller_index(*[mi.iround() for mi in (miller_indices.as_vec3_double() + offset).parts()])
def run(args):
phil = iotbx.phil.process_command_line(
args = args, master_string = master_phil)
work_params = phil.work.extract()
if ("--help" in args) :
libtbx.phil.parse(master_phil.show())
return
if ((work_params.d_min is None) or
(work_params.data is None) or
((work_params.model is None) and
work_params.scaling.algorithm != "mark1")):
raise Usage("cxi.merge "
"d_min=4.0 "
"data=~/scratch/r0220/006/strong/ "
"model=3bz1_3bz2_core.pdb")
if ((work_params.rescale_with_average_cell) and
(not work_params.set_average_unit_cell)) :
raise Usage("If rescale_with_average_cell=True, you must also specify "+
"set_average_unit_cell=True.")
miller_set = symmetry(
unit_cell = work_params.target_unit_cell,
space_group_info = work_params.target_space_group
).build_miller_set(
anomalous_flag = not work_params.merge_anomalous,
d_min = work_params.d_min)
from xfel.cxi.merging.general_fcalc import random_structure
i_model = random_structure(work_params)
# ---- Augment this code with any special procedures for x scaling
scaler = xscaling_manager(
miller_set = miller_set,
i_model = i_model,
params = work_params)
scaler.read_all()
sg = miller_set.space_group()
pg = sg.build_derived_laue_group()
rational_ops = []
for symop in pg:
rational_ops.append((matrix.sqr(symop.r().transpose().as_rational()),
symop.r().as_hkl()))
# miller_set.show_summary()
uc = work_params.target_unit_cell
hkl_asu = scaler.observations["hkl_id"]
imageno = scaler.observations["frame_id"]
intensi = scaler.observations["i"]
sigma_i = scaler.observations["sigi"]
lookup = scaler.millers["merged_asu_hkl"]
origH = scaler.observations["H"]
origK = scaler.observations["K"]
origL = scaler.observations["L"]
from cctbx.miller import map_to_asu
sgtype = miller_set.space_group_info().type()
aflag = miller_set.anomalous_flag()
from cctbx.array_family import flex
# FIXME in here perform the mapping to ASU for both the original and other
# index as an array-wise manipulation to make things a bunch faster...
# however this also uses a big chunk of RAM... FIXME also in here use
# cb_op.apply(indices) to get the indices reindexed...
original_indices = flex.miller_index()
for x in xrange(len(scaler.observations["hkl_id"])):
original_indices.append(lookup[hkl_asu[x]])
from cctbx.sgtbx import change_of_basis_op
I23 = change_of_basis_op('k, -h, l')
other_indices = I23.apply(original_indices)
map_to_asu(sgtype, aflag, original_indices)
map_to_asu(sgtype, aflag, other_indices)
# FIXME would be useful in here to have a less expensive way of finding the
# symmetry operation which gave the map to the ASU - perhaps best way is to
# make a new C++ map_to_asu which records this.
# FIXME in here recover the original frame structure of the data to
# logical frame objetcs - N.B. the frame will need to be augmented to test
# alternative indexings
# construct table of start / end indices for frames: now using Python
# range indexing
starts = [0]
ends = []
for x in xrange(1, len(scaler.observations["hkl_id"])):
if imageno[x] != imageno[x - 1]:
ends.append(x)
starts.append(x)
ends.append(len(scaler.observations["hkl_id"]))
keep_start = []
keep_end = []
for j, se in enumerate(zip(starts, ends)):
print 'processing frame %d: %d to %d' % (j, se[0], se[1])
s, e = se
isig = sum(i / s for i, s in zip(intensi[s:e], sigma_i[s:e])) / (e - s)
dmin = 100.0
for x in xrange(s, e):
d = uc.d(lookup[hkl_asu[x]])
if d < dmin:
dmin = d
if isig > 6.0 and dmin < 3.2:
keep_start.append(s)
keep_end.append(e)
starts = keep_start
ends = keep_end
print 'Keeping %d frames' % len(starts)
# then start running the comparison code
frames = []
for s, e in zip(starts, ends):
# FIXME need this from remap to ASU
misym = [0 for x in range(s, e)]
indices = [original_indices[x] for x in range(s, e)]
other = [other_indices[x] for x in range(s, e)]
intensities = intensi[s:e]
sigmas = sigma_i[s:e]
frames.append(Frame(uc, indices, other, intensities, sigmas))
reference = FrameFromReferenceMTZ()
fout = open('cc_reference.log', 'w')
for j, f in enumerate(frames):
_cc = reference.cc(f)
_oo = reference.cc_other(f)
print '%d %d %d %d %f %d %f' % (j, starts[j], ends[j], _cc[0], _cc[1],
_oo[0], _oo[1])
fout.write('%d %d %d %d %f %d %f\n' % (j, starts[j], ends[j],
_cc[0], _cc[1], _oo[0], _oo[1]))
fout.close()
return
def run(args):
phil = iotbx.phil.process_command_line(
args = args, master_string = master_phil)
work_params = phil.work.extract()
if ("--help" in args) :
libtbx.phil.parse(master_phil.show())
return
if ((work_params.d_min is None) or
(work_params.data is None) or
((work_params.model is None) and
work_params.scaling.algorithm != "mark1")):
raise Usage("cxi.merge "
"d_min=4.0 "
"data=~/scratch/r0220/006/strong/ "
"model=3bz1_3bz2_core.pdb")
if ((work_params.rescale_with_average_cell) and
(not work_params.set_average_unit_cell)) :
raise Usage("If rescale_with_average_cell=True, you must also specify "+
"set_average_unit_cell=True.")
miller_set = symmetry(
unit_cell = work_params.target_unit_cell,
space_group_info = work_params.target_space_group
).build_miller_set(
anomalous_flag = not work_params.merge_anomalous,
d_min = work_params.d_min)
from xfel.cxi.merging.general_fcalc import random_structure
i_model = random_structure(work_params)
# ---- Augment this code with any special procedures for x scaling
scaler = xscaling_manager(
miller_set = miller_set,
i_model = i_model,
params = work_params)
scaler.read_all()
sg = miller_set.space_group()
pg = sg.build_derived_laue_group()
rational_ops = []
for symop in pg:
rational_ops.append((matrix.sqr(symop.r().transpose().as_rational()),
symop.r().as_hkl()))
# miller_set.show_summary()
uc = work_params.target_unit_cell
hkl_asu = scaler.observations["hkl_id"]
imageno = scaler.observations["frame_id"]
intensi = scaler.observations["i"]
sigma_i = scaler.observations["sigi"]
lookup = scaler.millers["merged_asu_hkl"]
origH = scaler.observations["H"]
origK = scaler.observations["K"]
origL = scaler.observations["L"]
from cctbx.miller import map_to_asu
sgtype = miller_set.space_group_info().type()
aflag = miller_set.anomalous_flag()
from cctbx.array_family import flex
# FIXME in here perform the mapping to ASU for both the original and other
# index as an array-wise manipulation to make things a bunch faster...
# however this also uses a big chunk of RAM... FIXME also in here use
# cb_op.apply(indices) to get the indices reindexed...
original_indices = flex.miller_index()
for x in xrange(len(scaler.observations["hkl_id"])):
original_indices.append(lookup[hkl_asu[x]])
from cctbx.sgtbx import change_of_basis_op
I23 = change_of_basis_op('k, -h, l')
other_indices = I23.apply(original_indices)
map_to_asu(sgtype, aflag, original_indices)
map_to_asu(sgtype, aflag, other_indices)
# FIXME would be useful in here to have a less expensive way of finding the
# symmetry operation which gave the map to the ASU - perhaps best way is to
# make a new C++ map_to_asu which records this.
# FIXME in here recover the original frame structure of the data to
# logical frame objetcs - N.B. the frame will need to be augmented to test
# alternative indexings
# construct table of start / end indices for frames: now using Python
# range indexing
starts = [0]
ends = []
for x in xrange(1, len(scaler.observations["hkl_id"])):
if imageno[x] != imageno[x - 1]:
ends.append(x)
starts.append(x)
ends.append(len(scaler.observations["hkl_id"]))
keep_start = []
keep_end = []
for j, se in enumerate(zip(starts, ends)):
print 'processing frame %d: %d to %d' % (j, se[0], se[1])
s, e = se
isig = sum(i / s for i, s in zip(intensi[s:e], sigma_i[s:e])) / (e - s)
dmin = 100.0
for x in xrange(s, e):
d = uc.d(lookup[hkl_asu[x]])
if d < dmin:
dmin = d
if isig > 6.0 and dmin < 3.2:
keep_start.append(s)
keep_end.append(e)
starts = keep_start
ends = keep_end
print 'Keeping %d frames' % len(starts)
# then start running the comparison code
frames = []
for s, e in zip(starts, ends):
# FIXME need this from remap to ASU
misym = [0 for x in range(s, e)]
indices = [original_indices[x] for x in range(s, e)]
other = [other_indices[x] for x in range(s, e)]
intensities = intensi[s:e]
sigmas = sigma_i[s:e]
frames.append(Frame(uc, indices, other, intensities, sigmas))
cycle = 0
total_nref = sum([len(f.get_indices()) for f in frames])
# pre-scale the data - first determine average ln(k), B; then apply
kbs = [f.kb() for f in frames]
mn_k = sum([kb[0] for kb in kbs]) / len(kbs)
mn_B = sum([kb[1] for kb in kbs]) / len(kbs)
for f in frames:
f.scale_to_kb(mn_k, mn_B)
while True:
print 'Analysing %d frames' % len(frames)
print 'Cycle %d' % cycle
cycle += 1
print 'Power spectrum'
fn = frame_numbers(frames)
for j in sorted(fn):
print '%4d %4d' % (j, fn[j])
nref_cycle = sum([len(f.get_indices()) for f in frames])
assert(nref_cycle == total_nref)
# first work on the original indices
import numpy
common_reflections = numpy.zeros((len(frames), len(frames)),
dtype = numpy.short)
obs = { }
# for other hand add -j
for j, f in enumerate(frames):
indices = set(f.get_indices())
for i in indices:
_i = tuple(i)
if not _i in obs:
obs[_i] = []
obs[_i].append(j)
for hkl in obs:
obs[hkl].sort()
for j, f1 in enumerate(obs[hkl][:-1]):
for f2 in obs[hkl][j + 1:]:
if f1 * f2 > 0:
common_reflections[(abs(f1), abs(f2))] += 1
cmn_rfl_list = []
for f1 in range(len(frames)):
for f2 in range(f1 + 1, len(frames)):
if common_reflections[(f1, f2)] > 10:
cmn_rfl_list.append((common_reflections[(f1, f2)], f1, f2))
cmn_rfl_list.sort()
cmn_rfl_list.reverse()
joins = []
used = []
for n, f1, f2 in cmn_rfl_list:
if f1 in used or f2 in used:
continue
_cc = frames[f1].cc(frames[f2])
# really only need to worry about f2 which will get merged...
# merging multiple files together should be OK provided they are
# correctly sorted (though the order should not matter anyhow?)
# anyhow they are sorted anyway... ah as f2 > f1 then just sorting
# the list by f2 will make sure the data cascase correctly.
# p-value small (3% ish) for cc > 0.6 for > 10 observations -
# necessary as will be correlated due to Wilson curves though
# with B factor < 10 this is less of an issue
if _cc[0] > 10 and _cc[1] > 0.6:
print '%4d %.3f' % _cc, f1, f2
joins.append((f2, f1))
used.append(f2)
if not joins:
print 'No pairs found'
break
joins.sort()
joins.reverse()
for j2, j1 in joins:
rmerge = frames[j1].merge(frames[j2])
if rmerge:
print 'R: %4d %4d %6.3f' % (j1, j2, rmerge)
else:
print 'R: %4d %4d ------' % (j1, j2)
all_joins = [j for j in joins]
# then do the same for the alternative indices
other_reflections = numpy.zeros((len(frames), len(frames)),
dtype = numpy.short)
obs = { }
# for other hand add -j
for j, f in enumerate(frames):
indices = set(f.get_indices())
for i in indices:
_i = tuple(i)
if not _i in obs:
obs[_i] = []
obs[_i].append(j)
indices = set(f.get_other())
for i in indices:
_i = tuple(i)
if not _i in obs:
obs[_i] = []
obs[_i].append(-j)
for hkl in obs:
obs[hkl].sort()
for j, f1 in enumerate(obs[hkl][:-1]):
for f2 in obs[hkl][j + 1:]:
if f1 * f2 < 0:
other_reflections[(abs(f1), abs(f2))] += 1
oth_rfl_list = []
for f1 in range(len(frames)):
for f2 in range(f1 + 1, len(frames)):
if other_reflections[(f1, f2)] > 10:
oth_rfl_list.append((other_reflections[(f1, f2)], f1, f2))
joins = []
oth_rfl_list.sort()
oth_rfl_list.reverse()
for n, f1, f2 in oth_rfl_list:
if f1 in used or f2 in used:
continue
_cc = frames[f1].cc_other(frames[f2])
# really only need to worry about f2 which will get merged...
# merging multiple files together should be OK provided they are
# correctly sorted (though the order should not matter anyhow?)
# anyhow they are sorted anyway... ah as f2 > f1 then just sorting
# the list by f2 will make sure the data cascase correctly.
# p-value small (3% ish) for cc > 0.6 for > 10 observations -
# necessary as will be correlated due to Wilson curves though
# with B factor < 10 this is less of an issue
if _cc[0] > 10 and _cc[1] > 0.6:
print '%4d %.3f' % _cc, f1, f2
joins.append((f2, f1))
used.append(f2)
all_joins += joins
if not all_joins:
break
joins.sort()
joins.reverse()
for j2, j1 in joins:
frames[j2].reindex()
rmerge = frames[j1].merge(frames[j2])
if rmerge:
print 'R: %4d %4d %6.3f' % (j1, j2, rmerge)
else:
print 'R: %4d %4d ------' % (j1, j2)
continue
frames.sort()
print 'Biggest few: #frames; #unique refl'
j = -1
while frames[j].get_frames() > 1:
print frames[j].get_frames(), frames[j].get_unique_indices()
frames[j].output_as_scalepack(sg, 'scalepack-%d.sca' % j)
j -= 1
return
def simdata_pipeline():
data = gen_data.gen_data(args.i, load_hkl=False, Nshot_max=args.N)
if args.resoshuff:
hmap = np.load(args.i)["hkl_map"][()]
reso_bins = [24, 6.5] + list(np.linspace(2, 6.5, 25)[::-1])
reso_bins = [
24.9840, 4.3025, 4.3025, 3.4178, 3.4178, 2.9866, 2.9866, 2.7139,
2.7139, 2.5195, 2.5195, 2.3711, 2.3711, 2.2524, 2.2524, 2.1545,
2.1545, 2.0716, 2.0716, 2.0001
]
else:
hmap = None
reso_bins = None
guesses = gen_data.guess_data(data,
use_Iguess=False,
gain_guess=False,
perturbate=True,
perturbate_factor=.5,
hmap=hmap,
reso_bins=reso_bins)
truth = gen_data.guess_data(data, perturbate=False)
print("Loaded")
# t1_lb = time.time()
# lbfgs_solver = solvers.LogIsolverCurve(
# use_curvatures=True,
# data=data,
# guess=guesses, truth=truth)
# t2_lb = time.time()
# embed()
if args.weights:
weights = data['weights']
else:
weights = None
t1_eig = time.time()
ES = eigen_solver(data=data,
guess=guesses,
truth=truth,
lbfgs=False,
conj_grad=True,
plot=True,
plot_truth=True,
weights=weights,
sovlerization_maximus=args.solverize)
t2_eig = time.time()
if args.plot:
IB = np.exp(ES.helper.x[ES.Nhkl:2 * ES.Nhkl].as_numpy_array())
IA = np.exp(ES.helper.x[:ES.Nhkl].as_numpy_array())
IAtru = np.exp(ES.IAprm_truth.as_numpy_array())
IBtru = np.exp(ES.IBprm_truth.as_numpy_array())
import pylab as plt
plt.plot(IA, IAtru, '.')
plt.plot(IB, IBtru, '.')
ax = plt.gca()
ax.set_yscale('log')
ax.set_xscale('log')
plt.xlim(1e-1, 1e7)
plt.ylim(1e-1, 1e7)
plt.plot(IAtru, IBtru, '.')
plt.show()
from cctbx import sgtbx, crystal
from cctbx.array_family import flex
from cctbx import miller
from cxid9114 import utils
Nh = ES.Nhkl
IA = ES.helper.x[:Nh].as_numpy_array()
IB = ES.helper.x[Nh:2 * Nh].as_numpy_array()
#IA = ES.IAprm_truth.as_numpy_array()
#IB = ES.IBprm_truth.as_numpy_array()
#IA = ES.x_init[:Nh].as_numpy_array()
#IB = ES.x_init[Nh:2*Nh].as_numpy_array()
dataA = np.load(args.i)
hkl_map = dataA["hkl_map"][()]
hkl_map2 = {v: k for k, v in hkl_map.iteritems()}
Nhkl = len(hkl_map)
assert (Nh == Nhkl)
hout, Aout, Bout = [], [], []
for i in range(Nhkl):
h = hkl_map2[i]
valA = IA[i]
valB = IB[i]
hout.append(h)
Aout.append(np.sqrt(np.exp(valA)))
Bout.append(np.sqrt(np.exp(valB)))
sigA = np.ones(len(Aout)) #np.sqrt(Aout)
sigB = np.ones(len(Bout)) #np.sqrt(Bout)
sg = sgtbx.space_group(" P 4nw 2abw")
Symm = crystal.symmetry(unit_cell=(79, 79, 38, 90, 90, 90), space_group=sg)
hout = tuple(hout)
mil_idx = flex.miller_index(hout)
mil_set = miller.set(crystal_symmetry=Symm,
indices=mil_idx,
anomalous_flag=True)
Aout_flex = flex.double(np.ascontiguousarray(Aout))
Bout_flex = flex.double(np.ascontiguousarray(Bout))
sigA_flex = flex.double(np.ascontiguousarray(sigA))
sigB_flex = flex.double(np.ascontiguousarray(sigB))
mil_arA = miller.array(
mil_set, data=Aout_flex,
sigmas=sigA_flex).set_observation_type_xray_amplitude()
mil_arB = miller.array(
mil_set, data=Bout_flex,
sigmas=sigB_flex).set_observation_type_xray_amplitude()
#mil_arA = miller.array(mil_set, data=Aout_flex).set_observation_type_xray_amplitude()
#mil_arB = miller.array(mil_set, data=Bout_flex).set_observation_type_xray_amplitude()
from cxid9114.parameters import ENERGY_CONV
waveA = ENERGY_CONV / 8944.
waveB = ENERGY_CONV / 9034.
ucell = mil_arA.unit_cell()
sgi = mil_arA.space_group_info()
from iotbx import mtz
mtz_handle = mtz.object()
mtz_handle.set_title(title="MAD_MTZ")
mtz_handle.set_space_group_info(space_group_info=sgi)
#mtz_handle.set_hkl_base(unit_cell=ucell)
#mtz_cr = mtz_handle.crystals()[0]
mtz_cr = mtz_handle.add_crystal(name="Crystal",
project_name="project",
unit_cell=ucell)
dsetA = mtz_cr.add_dataset(name="datasetA", wavelength=waveA)
_ = dsetA.add_miller_array(miller_array=mil_arA, column_root_label="FAobs")
dsetB = mtz_cr.add_dataset(name="datasetB", wavelength=waveB)
_ = dsetB.add_miller_array(miller_array=mil_arB, column_root_label="FBobs")
mtz_handle.show_summary()
mtz_handle.write(args.o)
for i in range(10):
print ES.IAprm_truth[i], np.log(ES.guess['IAprm'][i]), ES.helper.x[i]
print ES.IBprm_truth[i], np.log(
ES.guess['IBprm'][i]), ES.helper.x[ES.Nhkl + i]
print ES.Gprm_truth[i], ES.guess["Gprm"][i], ES.helper.x[2 * ES.Nhkl +
i]
print
def load_4bs7_sf():
import os
from cctbx.array_family import flex
from cctbx import miller
sf_path = os.path.dirname(__file__)
sf_file = os.path.join(sf_path, "4bs7-sf.cif")
f = any_reflection_file(file_name=sf_file)
reader = f.file_content()
if reader is None:
raise ValueError(
"Be sure to install git lfs and pull in the actual file with 4bs7-sf.cif"
)
F = reader.build_miller_arrays()["r4bs7sf"]['_refln.F_meas_au_1']
Symm = F.crystal_symmetry()
Fhkl = {h: val for h, val in zip(F.indices(), F.data())}
Fd = reader.build_miller_arrays(
)['r4bs7sf']['_refln.pdbx_anom_difference_1']
Fdiff = {h: val for h, val in zip(Fd.indices(), Fd.data())}
hcommon = set(Fhkl.keys()).intersection(set(Fdiff.keys()))
Fpos = []
Fneg = []
hpos = []
hneg = []
for H in hcommon:
fneg = Fhkl[H] - Fdiff[H]
if fneg < 0:
continue
H_neg = -H[0], -H[1], -H[2]
Fpos.append(Fhkl[H])
hpos.append(H)
Fneg.append(fneg)
hneg.append(H_neg)
#val_low = vals_anom[H_neg][0] + diff[H][0]
#val_high = vals_anom[H_neg][0] # + .5*diff[H][0]
#if val_low <= 0:
# val_low = .1
# #from IPython import embed
# #embed()
#assert val_high >= 0
#vals_anom[H_neg][0] = val_low
#vals_anom[H][0] = val_high
##if val_low < 0:
## offset = abs(val_low)
## vals_anom[H_neg][0] = val_low + offset*2
## vals_anom[H][0] = val_high + offset*2
## propagate the error
#vals_anom[H_neg][1] = np.sqrt(vals_anom[H_neg][1]**2 + diff[H][1]**2)
#vals_anom[H][1] = np.sqrt(vals_anom[H][1] ** 2 + diff[H][1] ** 2)
#hout = tuple(vals_anom.keys())
Fflex = flex.double(Fpos + Fneg)
hflex = flex.miller_index(hpos + hneg)
mset = miller.set(crystal_symmetry=Symm,
indices=hflex,
anomalous_flag=True)
#Fdata = flex.double([vals_anom[h][0] for h in hout])
#Fsigmas = flex.double([vals_anom[h][1] for h in hout])
#Fhkl_anom = miller.array(mset, data=Fdata, sigmas=Fsigmas).set_observation_type_xray_amplitude()
Fhkl_anom = miller.array(mset,
data=Fflex).set_observation_type_xray_amplitude()
return Fhkl_anom
def _index_finish(self):
"""Perform the indexer post-processing as required."""
# ok, in here now ask if this solution was sensible!
if not self.get_indexer_user_input_lattice():
lattice = self._indxr_lattice
cell = self._indxr_cell
lattice2, cell2 = xds_check_indexer_solution(
os.path.join(self.get_working_directory(), "XPARM.XDS"),
os.path.join(self.get_working_directory(), "SPOT.XDS"),
)
Debug.write("Centring analysis: %s => %s" % (lattice, lattice2))
doubled_lattice = False
for j in range(3):
if int(round(cell2[j] / cell[j])) == 2:
doubled_lattice = True
axes = "A", "B", "C"
Debug.write("Lattice axis doubled: %s" % axes[j])
if (self._idxref_subtree_problem and
(lattice2 != lattice)) or doubled_lattice:
# hmm.... looks like we don't agree on the correct result...
# update the putative correct result as input
Debug.write("Detected pseudocentred lattice")
Debug.write("Inserting solution: %s " % lattice2 +
"%6.2f %6.2f %6.2f %6.2f %6.2f %6.2f" % cell2)
self._indxr_replace(lattice2, cell2)
Debug.write("Set lattice: %s" % lattice2)
Debug.write("Set cell: %f %f %f %f %f %f" % cell2)
# then rerun
self.set_indexer_done(False)
return
# finally read through SPOT.XDS and XPARM.XDS to get an estimate
# of the low resolution limit - this should be pretty straightforward
# since what I want is the resolution of the lowest resolution indexed
# spot..
spot_file = os.path.join(self.get_working_directory(), "SPOT.XDS")
experiment = self.get_indexer_experiment_list()[0]
crystal_model = experiment.crystal
from iotbx.xds import spot_xds
spot_xds_handle = spot_xds.reader()
spot_xds_handle.read_file(spot_file)
from cctbx.array_family import flex
miller_indices = flex.miller_index(spot_xds_handle.miller_index)
# only those reflections that were actually indexed
miller_indices = miller_indices.select(miller_indices != (0, 0, 0))
from scitbx import matrix
ub = matrix.sqr(crystal_model.get_A())
dmax = 1.05 * flex.max(
1 / (ub.elems * miller_indices.as_vec3_double()).norms())
Debug.write("Low resolution limit assigned as: %.2f" % dmax)
self._indxr_low_resolution = dmax
def _index_finish(self):
'''Perform the indexer post-processing as required.'''
# ok, in here now ask if this solution was sensible!
if not self.get_indexer_user_input_lattice():
lattice = self._indxr_lattice
cell = self._indxr_cell
lattice2, cell2 = xds_check_indexer_solution(
os.path.join(self.get_working_directory(), 'XPARM.XDS'),
os.path.join(self.get_working_directory(), 'SPOT.XDS'))
Debug.write('Centring analysis: %s => %s' % \
(lattice, lattice2))
doubled_lattice = False
for j in range(3):
if int(round(cell2[j] / cell[j])) == 2:
doubled_lattice = True
axes = 'A', 'B', 'C'
Debug.write('Lattice axis doubled: %s' % axes[j])
if (self._idxref_subtree_problem and (lattice2 != lattice)) or \
doubled_lattice:
# hmm.... looks like we don't agree on the correct result...
# update the putative correct result as input
Debug.write('Detected pseudocentred lattice')
Debug.write('Inserting solution: %s ' % lattice2 +
'%6.2f %6.2f %6.2f %6.2f %6.2f %6.2f' % cell2)
self._indxr_replace(lattice2, cell2)
Debug.write('Set lattice: %s' % lattice2)
Debug.write('Set cell: %f %f %f %f %f %f' % \
cell2)
# then rerun
self.set_indexer_done(False)
return
# finally read through SPOT.XDS and XPARM.XDS to get an estimate
# of the low resolution limit - this should be pretty straightforward
# since what I want is the resolution of the lowest resolution indexed
# spot..
spot_file = os.path.join(self.get_working_directory(), 'SPOT.XDS')
experiment = self.get_indexer_experiment_list()[0]
detector = experiment.detector
beam = experiment.beam
goniometer = experiment.goniometer
scan = experiment.scan
crystal_model = experiment.crystal
from iotbx.xds import spot_xds
spot_xds_handle = spot_xds.reader()
spot_xds_handle.read_file(spot_file)
from cctbx.array_family import flex
centroids_px = flex.vec3_double(spot_xds_handle.centroid)
miller_indices = flex.miller_index(spot_xds_handle.miller_index)
# only those reflections that were actually indexed
centroids_px = centroids_px.select(miller_indices != (0,0,0))
miller_indices = miller_indices.select(miller_indices != (0,0,0))
ub = crystal_model.get_A()
dmax = 1.05 * flex.max(1/(ub.elems * miller_indices.as_vec3_double()).norms())
Debug.write('Low resolution limit assigned as: %.2f' % dmax)
self._indxr_low_resolution = dmax
return
