def parameter_based_model(self,params):
PIXEL_SZ = 0.11 # mm/pixel
all_model = mark3_collect_data(self.frame_id, self.HKL)
self.FRAMES["refined_detector_origin"] = flex.vec3_double(len(self.FRAMES["frame_id"]))
for iframe in xrange(len(self.FRAMES["frame_id"])):
frame_id = self.FRAMES["frame_id"][iframe]
self.frame_id_to_param_no[frame_id] = iframe
detector_origin = self.parameter_based_model_one_frame_detail(frame_id,iframe,all_model)
try:
self.bandpass_models[frame_id].gaussian_fast_slow()
except Exception,e:
print "Exception from picture",e
raise e
try:
all_model.collect_mean_position(self.bandpass_models[frame_id].mean_position,
self.bandpass_models[frame_id].observed_flag,
frame_id);
all_model.collect_distance(self.bandpass_models[frame_id].part_distance,frame_id)
self.FRAMES["refined_detector_origin"][iframe] = detector_origin/(-PIXEL_SZ)
except Exception,e:
print "Exception from collect",e
raise e
def parameter_based_model(self,params):
PIXEL_SZ = 0.11 # mm/pixel
all_model = mark3_collect_data(self.frame_id, self.HKL)
self.FRAMES["refined_detector_origin"] = flex.vec3_double(len(self.FRAMES["frame_id"]))
for iframe in range(len(self.FRAMES["frame_id"])):
frame_id = self.FRAMES["frame_id"][iframe]
self.frame_id_to_param_no[frame_id] = iframe
detector_origin = self.parameter_based_model_one_frame_detail(frame_id,iframe,all_model)
try:
self.bandpass_models[frame_id].gaussian_fast_slow()
except Exception as e:
print "Exception from picture",e
raise e
try:
all_model.collect_mean_position(self.bandpass_models[frame_id].mean_position,
self.bandpass_models[frame_id].observed_flag,
frame_id);
all_model.collect_distance(self.bandpass_models[frame_id].part_distance,frame_id)
self.FRAMES["refined_detector_origin"][iframe] = detector_origin/(-PIXEL_SZ)
except Exception as e:
print "Exception from collect",e
raise e
#print "HATTNE check 0", list(self.bandpass_models[frame_id].mean_position), len(self.bandpass_models[frame_id].mean_position)
#print "HATTNE check 1", list(self.bandpass_models[frame_id].observed_flag), len(self.bandpass_models[frame_id].observed_flag)
sq_displacements = ((all_model.cx - self.spotcx)*(all_model.cx - self.spotcx) +
(all_model.cy - self.spotcy)*(all_model.cy - self.spotcy))
# print "In parameter_based_model, HATTNE got sqdisplacements", flex.mean(sq_displacements)
# print " * am, am", flex.mean(all_model.cx), flex.mean(all_model.cy), len(all_model.cx), len(all_model.cy)
# print " * cx, cy", flex.mean(self.spotcx), \
# flex.mean(self.spotcy), \
# len(self.spotcx), len(self.spotcy)
# print " * diffs ", flex.mean(all_model.cx - self.spotcx), flex.mean(all_model.cy - self.spotcy), flex.max(flex.abs(all_model.cx - self.spotcx)), flex.max(flex.abs(all_model.cy - self.spotcy))
# from matplotlib import pyplot as plt
# plt.plot(self.spotfx, self.spotfy, "r.")
## plt.plot(self.spotcx, self.spotcy, "g.")
# plt.plot(all_model.cx, all_model.cy, "g.")
# plt.show()
#print list(all_model.cx - self.spotcx)
selected_sq_displacements = sq_displacements.select( all_model.flags == True )
#print "Root Mean squared displacement all spots %8.3f"%math.sqrt(
# flex.sum(selected_sq_displacements)/len(selected_sq_displacements))
return all_model.cx, all_model.cy, all_model.flags, all_model.part_distance
def run_cycle_b(self,iteration):
for iframe in xrange(len(self.FRAMES["frame_id"])):
frame_id = self.FRAMES["frame_id"][iframe]
self.frame_id_to_param_no[frame_id] = iframe
self.bandpass_models = {}
all_model = mark3_collect_data(self.frame_id, self.HKL)
for iframe in xrange(min(self.n_refined_frames,len(self.FRAMES["frame_id"]))):
frame_id = self.FRAMES["frame_id"][iframe]
file_name = self.FRAMES["unique_file_name"][iframe]
self.parameter_based_model_one_frame_detail(frame_id,iframe,all_model)
#instantiate a helper class for holding the per-frame data
class per_frame_helper:
def __init__(pfh):
pfh.master_tiles = flex.int()
pfh.spotfx = flex.double()
pfh.spotfy = flex.double()
pfh.cosine = [math.cos(self.tile_rotations.x[tidx]*(math.pi/180))
for tidx in xrange(len(self.To_x))]
pfh.sine = [math.sin(self.tile_rotations.x[tidx]*(math.pi/180))
for tidx in xrange(len(self.To_x))]
self.parameter_based_model_one_frame_detail(frame_id,iframe,all_model)
self.bandpass_models[frame_id].gaussian_fast_slow()
mean_position = self.bandpass_models[frame_id].mean_position
first_index = all_model.get_first_index(frame_id)
for ridx in xrange(mean_position.size()):
pfh.master_tiles.append( self.master_tiles[first_index + ridx] );
pfh.spotfx.append( self.spotfx[first_index + ridx] );
pfh.spotfy.append( self.spotfy[first_index + ridx] );
def fvec_callable(pfh,current_values,frame_id,iframe,all_model):
#print "HATTNE entering fvec_callable()"
self.frame_roty.x[iframe] = current_values[0]
self.frame_rotx.x[iframe] = current_values[1]
# self.mean_energy_factor.x[iframe] = current_values[2]
# self.bandpass_logfac.x[iframe] = current_values[3]
# self.mosaicity_factor.x[iframe] = current_values[4]
for iparam in xrange(self.bandpass_models["n_independent"]):
self.g_factor.x[iparam+6*iframe] = current_values[2+iparam]
try:
self.parameter_based_model_one_frame_detail(frame_id,iframe,all_model)
except Exception, e:
print "Failed on", iframe, self.FRAMES["unique_file_name"][iframe]
raise e
#print " HATTNE marker #0", frame_id, type(self.bandpass_models), self.bandpass_models.keys(), type(self.bandpass_models[frame_id])
self.bandpass_models[frame_id].gaussian_fast_slow()
#print " HATTNE marker #1"
mean_position = self.bandpass_models[frame_id].mean_position
translations = self.tile_translations.x
fval = []
for ridx in xrange(mean_position.size()):
itile = pfh.master_tiles[ridx];
calc_minus_To_x = mean_position[ridx][1] - self.To_x[itile];
calc_minus_To_y = mean_position[ridx][0] - self.To_y[itile];
rotated_o_x = calc_minus_To_x * pfh.cosine[itile]\
- calc_minus_To_y * pfh.sine[itile];
rotated_o_y = calc_minus_To_x * pfh.sine[itile]\
+ calc_minus_To_y * pfh.cosine[itile];
model_calcx = rotated_o_x + (self.To_x[itile] + translations[2*itile]);
model_calcy = rotated_o_y + (self.To_y[itile] + translations[2*itile+1]);
delx = model_calcx - pfh.spotfx[ridx];
dely = model_calcy - pfh.spotfy[ridx];
fval.append(delx)
fval.append(dely)
cum = 0.
for item in fval:
cum += item*item
rmsd = math.sqrt( cum / (len(fval)/2) )
print "rmsd", rmsd
return fval
self.helper = per_frame_helper()
print "Trying iframe",iframe,"independent=%d"%self.bandpass_models["n_independent"],
results = leastsq(
func = self.helper.fvec_callable,
x0 = [self.frame_roty.x[iframe],self.frame_rotx.x[iframe],
# self.mean_energy_factor.x[iframe],self.bandpass_logfac.x[iframe],
# self.mosaicity_factor.x[iframe]
] + [self.g_factor.x[n+6*iframe]
for n in xrange(self.bandpass_models["n_independent"])],
args = (frame_id,iframe,all_model),
Dfun = None, #estimate the Jacobian
full_output = True)
print "with %d reflections"%self.bandpass_models[frame_id].mean_position.size(),
print "result %6.2f degrees"%(results[0][0]*180./math.pi),
print "result %6.2f degrees"%(results[0][1]*180./math.pi),
#modify this line to deal with cubic space group
print "energy factor %6.4f"%(results[0][2]),"metrical%1d %7.5f %7.5f"%(iteration,results[0][2],results[0][3]),
fff = results[2]["fvec"]
cum = 0.
for item in fff:
cum += item*item
rmsd = math.sqrt( cum / (len(fff)/2) )
print "rmsd", rmsd,
print file_name
def parameter_based_model(self, params):
PIXEL_SZ = 0.11 # mm/pixel
all_model = mark3_collect_data(self.frame_id, self.HKL)
for iframe in range(len(self.FRAMES["frame_id"])):
frame_id = self.FRAMES["frame_id"][iframe]
if frame_id not in self.bandpass_models:
reserve_orientation = self.FRAMES["orientation"][iframe]
effective_orientation = reserve_orientation
#Not necessary to apply the 3 offset rotations; they have apparently
# been applied already.\
# .rotate_thru((1,0,0),self.FRAMES["rotation100_rad"][iframe]
# ).rotate_thru((0,1,0),self.FRAMES["rotation010_rad"][iframe]
# ).rotate_thru((0,0,1),self.FRAMES["rotation001_rad"][iframe])
detector_origin = col((-self.FRAMES["beam_x"][iframe],
-self.FRAMES["beam_y"][iframe], 0.))
crystal = symmetry(unit_cell=effective_orientation.unit_cell(),
space_group="P1")
indices = all_model.frame_indices(frame_id)
parameters = parameters_bp3(
indices=indices,
orientation=effective_orientation,
incident_beam=col(correction_vectors.INCIDENT_BEAM),
packed_tophat=col((1., 1., 0.)),
detector_normal=col(correction_vectors.DETECTOR_NORMAL),
detector_fast=col((0., 1., 0.)),
detector_slow=col((1., 0., 0.)),
pixel_size=col((PIXEL_SZ, PIXEL_SZ, 0)),
pixel_offset=col((0., 0., 0.0)),
distance=self.FRAMES["distance"][iframe],
detector_origin=detector_origin)
ucbp3 = use_case_bp3(parameters=parameters)
ucbp3.set_active_areas(
self.tiles) #params.effective_tile_boundaries
integration_signal_penetration = 0.5
ucbp3.set_sensor_model(
thickness_mm=0.5,
mu_rho=8.36644, # CS_PAD detector at 1.3 Angstrom
signal_penetration=integration_signal_penetration)
half_mosaicity_rad = self.FRAMES["half_mosaicity_deg"][
iframe] * pi / 180.
ucbp3.set_mosaicity(half_mosaicity_rad)
ucbp3.set_bandpass(self.FRAMES["wave_HE_ang"][iframe],
self.FRAMES["wave_LE_ang"][iframe])
ucbp3.set_orientation(effective_orientation)
ucbp3.set_domain_size(self.FRAMES["domain_size_ang"][iframe])
ucbp3.picture_fast_slow_force()
self.bandpass_models[frame_id] = ucbp3
all_model.collect(self.bandpass_models[frame_id].hi_E_limit,
self.bandpass_models[frame_id].lo_E_limit,
self.bandpass_models[frame_id].observed_flag,
frame_id)
sq_displacements = ((all_model.cx - self.spotcx) *
(all_model.cx - self.spotcx) +
(all_model.cy - self.spotcy) *
(all_model.cy - self.spotcy))
selected_sq_displacements = sq_displacements.select(
all_model.flags == True)
print("Root Mean squared displacement all spots %8.3f" %
math.sqrt(
flex.sum(selected_sq_displacements) /
len(selected_sq_displacements)))
return all_model.cx, all_model.cy, all_model.flags
def parameter_based_model(self,params):
PIXEL_SZ = 0.11 # mm/pixel
all_model = mark3_collect_data(self.frame_id, self.HKL)
for iframe in xrange(len(self.FRAMES["frame_id"])):
frame_id = self.FRAMES["frame_id"][iframe]
if not self.bandpass_models.has_key(frame_id):
reserve_orientation = self.FRAMES["orientation"][iframe]
effective_orientation = reserve_orientation
#Not necessary to apply the 3 offset rotations; they have apparently
# been applied already.\
# .rotate_thru((1,0,0),self.FRAMES["rotation100_rad"][iframe]
# ).rotate_thru((0,1,0),self.FRAMES["rotation010_rad"][iframe]
# ).rotate_thru((0,0,1),self.FRAMES["rotation001_rad"][iframe])
detector_origin = col((-self.FRAMES["beam_x"][iframe],
-self.FRAMES["beam_y"][iframe], 0.))
crystal = symmetry(unit_cell=effective_orientation.unit_cell(),space_group = "P1")
indices = all_model.frame_indices(frame_id)
parameters = parameters_bp3(
indices=indices, orientation=effective_orientation,
incident_beam=col(correction_vectors.INCIDENT_BEAM),
packed_tophat=col((1.,1.,0.)),
detector_normal=col(correction_vectors.DETECTOR_NORMAL),
detector_fast=col((0.,1.,0.)),detector_slow=col((1.,0.,0.)),
pixel_size=col((PIXEL_SZ,PIXEL_SZ,0)),
pixel_offset=col((0.,0.,0.0)),
distance=self.FRAMES["distance"][iframe],
detector_origin=detector_origin
)
ucbp3 = use_case_bp3(parameters=parameters)
ucbp3.set_active_areas( self.tiles ) #params.effective_tile_boundaries
integration_signal_penetration=0.5
ucbp3.set_sensor_model( thickness_mm = 0.5, mu_rho = 8.36644, # CS_PAD detector at 1.3 Angstrom
signal_penetration = integration_signal_penetration)
half_mosaicity_rad = self.FRAMES["half_mosaicity_deg"][iframe] * pi/180.
ucbp3.set_mosaicity(half_mosaicity_rad)
ucbp3.set_bandpass(self.FRAMES["wave_HE_ang"][iframe],self.FRAMES["wave_LE_ang"][iframe])
ucbp3.set_orientation(effective_orientation)
ucbp3.set_domain_size(self.FRAMES["domain_size_ang"][iframe])
ucbp3.picture_fast_slow_force()
self.bandpass_models[frame_id]=ucbp3
all_model.collect(self.bandpass_models[frame_id].hi_E_limit,
self.bandpass_models[frame_id].lo_E_limit,
self.bandpass_models[frame_id].observed_flag,
frame_id);
sq_displacements = ((all_model.cx - self.spotcx)*(all_model.cx - self.spotcx) +
(all_model.cy - self.spotcy)*(all_model.cy - self.spotcy))
selected_sq_displacements = sq_displacements.select( all_model.flags == True )
print "Root Mean squared displacement all spots %8.3f"%math.sqrt(
flex.sum(selected_sq_displacements)/len(selected_sq_displacements))
return all_model.cx, all_model.cy, all_model.flags