def main(data, only_merohedral):
indambh = indamb_handler()
intFileList = read_pickles([data])
if intFileList:
obsList = {}
for intFileName in intFileList:
intPickle = read_frame(intFileName)
try:
obs = intPickle['observations'][0]
obsList[intFileName] = obs
except Exception as e:
print "Warning:", e
pass
for key, value in obsList.iteritems():
if only_merohedral:
flag_all = False
else:
flag_all = True
ops = indambh.generate_twin_operators(value, flag_all=flag_all)
if ops:
print os.path.basename(
key
), '%6.1f,%6.1f,%6.1f,%6.1f,%6.1f,%6.1f' % value.unit_cell(
).parameters(), ' '.join(
[op.operator.r().as_hkl() for op in ops])
else:
print os.path.basename(
key
), '%6.1f,%6.1f,%6.1f,%6.1f,%6.1f,%6.1f' % value.unit_cell(
).parameters(), 'Twining operators not found'
def get_observations(self, pickle_filename, iparams):
main_obs_pickle = read_frame(pickle_filename)
prh = postref_handler()
avg_mode = 'average'
try:
inputs, txt_org = prh.organize_input(
main_obs_pickle,
iparams,
avg_mode,
pickle_filename=pickle_filename)
main_obs = inputs[0]
except Exception:
print 'Error reading input pickle.'
return None
main_asu = main_obs.map_to_asu().merge_equivalents().array()
#get other indexing alternatives
if iparams.indexing_ambiguity.mode == 'Forced':
#generate other basis format according to the list
alternates = self.generate_forced_reindex_sets(
main_asu, iparams.indexing_ambiguity.assigned_basis)
else:
alternates = self.generate_reindex_sets(main_asu)
return alternates
def get_Eoc_corrected_observations(pickle_filename, iparams):
'''
Read pickle file name and output Eoc corrected original miller array object.
'''
observations_pickle = read_frame(pickle_filename)
observations_original = observations_pickle["observations"][0]
wavelength = observations_pickle["wavelength"]
crystal_init_orientation = observations_pickle["current_orientation"][0]
uc_params = observations_original.unit_cell().parameters()
detector_distance_mm = observations_pickle['distance']
mm_predictions = iparams.pixel_size_mm * (
observations_pickle['mapped_predictions'][0])
xbeam = observations_pickle["xbeam"]
ybeam = observations_pickle["ybeam"]
alpha_angle = flex.double([math.atan(abs(pred[0]-xbeam)/abs(pred[1]-ybeam)) \
for pred in mm_predictions])
spot_pred_x_mm = flex.double([pred[0] - xbeam for pred in mm_predictions])
spot_pred_y_mm = flex.double([pred[1] - ybeam for pred in mm_predictions])
#filter resolution
i_sel_res = observations_original.resolution_filter_selection(\
d_max=iparams.iotacc.d_max, d_min=iparams.iotacc.d_min)
observations_original = observations_original.customized_copy(\
indices=observations_original.indices().select(i_sel_res), \
data=observations_original.data().select(i_sel_res), \
sigmas=observations_original.sigmas().select(i_sel_res))
alpha_angle = alpha_angle.select(i_sel_res)
spot_pred_x_mm = spot_pred_x_mm.select(i_sel_res)
spot_pred_y_mm = spot_pred_y_mm.select(i_sel_res)
#Filter weak
i_sel = (observations_original.data() /
observations_original.sigmas()) > iparams.iotacc.sigma_min
observations_original = observations_original.customized_copy(\
indices=observations_original.indices().select(i_sel),\
data=observations_original.data().select(i_sel),\
sigmas=observations_original.sigmas().select(i_sel))
alpha_angle = alpha_angle.select(i_sel)
spot_pred_x_mm = spot_pred_x_mm.select(i_sel)
spot_pred_y_mm = spot_pred_y_mm.select(i_sel)
#calculate spot radius
from prime.postrefine.mod_leastsqr import calc_spot_radius
spot_radius = calc_spot_radius(
sqr(crystal_init_orientation.reciprocal_matrix()),
observations_original.indices(), wavelength)
G = 1
B = 0
from prime.postrefine.mod_leastsqr import calc_partiality_anisotropy_set
two_theta = observations_original.two_theta(wavelength=wavelength).data()
sin_theta_over_lambda_sq = observations_original.two_theta(
wavelength=wavelength).sin_theta_over_lambda_sq().data()
ry = 0
rz = 0
re = iparams.gamma_e
rotx = 0
roty = 0
#calc partiality
partiality_init, delta_xy_init, rs_init, rh_init = calc_partiality_anisotropy_set(
crystal_init_orientation.unit_cell(), rotx, roty,
observations_original.indices(), ry, rz, spot_radius, re, two_theta,
alpha_angle, wavelength, crystal_init_orientation, spot_pred_x_mm,
spot_pred_y_mm, detector_distance_mm, iparams.partiality_model,
iparams.flag_beam_divergence)
from prime.postrefine.mod_leastsqr import calc_full_refl
I_full = calc_full_refl(observations_original.data(),
sin_theta_over_lambda_sq, G, B, partiality_init,
rs_init, iparams.flag_volume_correction)
sigI_full = calc_full_refl(observations_original.sigmas(),
sin_theta_over_lambda_sq, G, B, partiality_init,
rs_init, iparams.flag_volume_correction)
observations_Eoc_corrected = observations_original.customized_copy(
data=I_full, sigmas=sigI_full)
return observations_Eoc_corrected, observations_original
print "Please specify pixel size (eg. pixel_size_mm=0.079346)"
exit()
return data, hklrefin, pixel_size_mm, target_unit_cell, d_min, d_max
if (__name__ == "__main__"):
uc_tol = 3
ry, rz, re, rotx, roty = (0, 0, 0.008, 0, 0)
flag_beam_divergence = False
lambda_template = flex.double(range(-50, 50, 1)) / 1000
#0 .read input parameters and frames (pickle files)
data, hklrefin, pixel_size_mm, target_unit_cell, \
d_min, d_max = read_input(args = sys.argv[1:])
frame_files = read_pickles(data)
for pickle_filename in frame_files:
observations_pickle = read_frame(pickle_filename)
pickle_filename_arr = pickle_filename.split('/')
pickle_filename_only = pickle_filename_arr[len(pickle_filename_arr) -
1]
mxh = mx_handler()
flag_hklisoin_found, miller_array_iso = mxh.get_miller_array_from_reflection_file(
hklrefin)
observations = observations_pickle["observations"][0]
#check if the uc is good
flag_good_unit_cell = good_unit_cell(
observations.unit_cell().parameters(),
None,
uc_tol,
target_unit_cell=target_unit_cell)
#update lambda_set
lambda_set = lambda_template + observations_pickle["wavelength"]
exit()
return data, data_sweep
if __name__ == "__main__":
# Read input parameters and frames (pickle files)
data_fine, data_sweep = read_input(args=sys.argv[1:])
pixel_size_mm = 0.079346
# read all the pickle files from fine-slice data
frames_fine = read_pickles(data_fine)
# get a sample reflections
sample_no = 0
obs_fine_sample = None
for i in range(2000):
frame = frames_fine[i]
pickle_fine = read_frame(frame)
obs_fine = pickle_fine["observations"][0]
obs_fine = obs_fine.select(obs_fine.data() > 0)
if len(obs_fine.data()) > 5:
print(frame)
for index, d, I, sigI in zip(
obs_fine.indices(),
obs_fine.d_spacings().data(),
obs_fine.data(),
obs_fine.sigmas(),
):
print(index, d, I, sigI)
obs_fine_sample = obs_fine.deep_copy()
# break
sample_no += 1
"""