from __future__ import absolute_import, division, print_function from six.moves import range from scipy.optimize import leastsq # special import import math,copy import scitbx.math from cctbx.sgtbx import tensor_rank_2_constraints from scitbx.array_family import flex from xfel.metrology.mark0 import correction_vectors from xfel.metrology.mark3 import fit_translation2 from xfel.metrology import mark3_collect_data from xfel import get_radial_tangential_vectors from scitbx.lbfgs.tst_curvatures import lbfgs_with_curvatures_mix_in from rstbx.bandpass import parameters_bp3 from scitbx.matrix import col from cctbx.crystal import symmetry from math import pi from scitbx import matrix from xfel.metrology.legacy_scale import mark5_iteration,vector_collection from xfel.metrology.legacy_scale import bandpass_gaussian from rstbx.symmetry.constraints import AGconvert from six.moves import zip #XXX remove the xfel/metrology/legacy_scale wrapping for AGconvert; not needed class fit_translation4(mark5_iteration,fit_translation2): 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 detector_origin_analysis(self): self.FRAMES["detector_origin_x_refined"]=flex.double() self.FRAMES["detector_origin_y_refined"]=flex.double() self.FRAMES["distance_refined"]=flex.double() for iframe in range(len(self.FRAMES["frame_id"])): if iframe < self.n_refined_frames: SIGN = -1. PIXEL_SZ = 0.11 # mm/pixel detector_origin = col((-self.FRAMES["beam_x"][iframe] + SIGN * PIXEL_SZ * self.frame_translations.x[2*iframe], -self.FRAMES["beam_y"][iframe] + SIGN * PIXEL_SZ * self.frame_translations.x[1+2*iframe], 0.)) self.FRAMES["detector_origin_x_refined"].append(detector_origin[0]) self.FRAMES["detector_origin_y_refined"].append(detector_origin[1]) self.FRAMES["distance_refined"].append( self.frame_distances.x[iframe] + self.FRAMES["distance"][iframe] ) xm = flex.mean_and_variance(self.FRAMES["detector_origin_x_refined"]) ym = flex.mean_and_variance(self.FRAMES["detector_origin_y_refined"]) print("Beam x mean %7.3f sigma %7.3f mm"%( xm.mean(), xm.unweighted_sample_standard_deviation())) print("Beam y mean %7.3f sigma %7.3f mm"%( ym.mean(), ym.unweighted_sample_standard_deviation())) time_series = False import os files = [os.path.basename(f) for f in self.FRAMES["unique_file_name"]] longs = [long("".join([a for a in name if a.isdigit()]))//1000 for name in files] floats = flex.double([float(L) for L in longs])[ :len(self.FRAMES["detector_origin_x_refined"])] order = flex.sort_permutation(floats) time_sorted_x_beam = self.FRAMES["detector_origin_x_refined"].select(order) time_sorted_y_beam = self.FRAMES["detector_origin_y_refined"].select(order) if time_series: from matplotlib import pyplot as plt plt.plot(range(len(order)),time_sorted_x_beam,"r-") plt.plot(range(len(order)),time_sorted_y_beam,"b-") plt.show() for item in order: print(files[item], "%8.3f %8.3f dist %8.3f"%( self.FRAMES["detector_origin_x_refined"][item], self.FRAMES["detector_origin_y_refined"][item], self.FRAMES["distance_refined"][item])) def __init__(self,params): self.optional_params = None self.frame_id_to_param_no = {} correction_vectors.__init__(self) # XXX Set in mark0.correction_vectors.read_data() #self.nominal_tile_centers(params.effective_tile_boundaries) self.params = params self.read_data(params) # for eventual write-out, deep copy the input: self.OUTPUT = copy.deepcopy(self.FRAMES) if params.max_frames==None: FR_LIMIT = len(self.FRAMES["frame_id"]) # don't adjust for degrees of freedom self.n_refined_frames = FR_LIMIT else: self.n_refined_frames = params.max_frames # XXX CHECK THIS BLOCK MORE CAREFULLY! mark5_iteration.__init__(self) self.tile_translations=self.register( "tile_trans",ndata=len(self.tiles) // 4,kdim=2,data=[0.]*(len(self.tiles) // 2)) # x & y displacements for each of 64 tiles self.tile_rotations=self.register("tile_rot",ndata=len(self.tiles) // 4,data=[0.]*(len(self.tiles) // 4)) self.frame_translations=self.register( "frame_trans",ndata=self.n_refined_frames,kdim=2,data=[0.]*(2*self.n_refined_frames)) self.frame_distances=self.register("frame_distance", ndata=self.n_refined_frames,data=[0.]*self.n_refined_frames) self.frame_rotz=self.register("frame_rotz", ndata=self.n_refined_frames,data=[0.]*self.n_refined_frames) self.frame_roty=self.register_local("frame_roty", ndata=self.n_refined_frames,data=[0.]*self.n_refined_frames) self.frame_rotx=self.register_local("frame_rotx", ndata=self.n_refined_frames,data=[0.]*self.n_refined_frames) self.mean_energy_factor=self.register_local("mean_energy_factor", ndata=self.n_refined_frames,data=[1.]*self.n_refined_frames) self.bandpass_logfac=self.register_local("bandpass_logfac", ndata=self.n_refined_frames,data=[0.]*self.n_refined_frames) self.mosaicity_factor=self.register_local("mosaicity_factor", ndata=self.n_refined_frames,data=[1.]*self.n_refined_frames) self.g_factor=self.register_local("g_factor", ndata=self.n_refined_frames,kdim=6,data=[1.]*6*self.n_refined_frames) self.vector_data = vector_collection(self.frame_id, self.HKL) self.jacobian_frame_roty = self.vector_data.register(tag="frame_roty") self.jacobian_frame_rotx = self.vector_data.register(tag="frame_rotx") """0. Read in only 500 frames, refine only 20 1. Define the new parameter here. 2. Define its new behavior in parameter_based_function() 3. set use_curvatures=False 4. implement refinement with finite differences: include the array name in setting compute_finite_difference_gradients_if_requested() fix the requirement for "zip" verify fd_gradients go to zero upon convergence verify parameter vector has reasonable values 5. implement analytic gradients, list out comparison columns 6. document the gradients in a tex file 7. implement curvatures & flag them in here """ self.x = self.as_x_array() def compute_finite_difference_gradients_if_requested(self): for param_array,tag in zip([self.frame_rotz],["frame_rotz"]): result = flex.double() for np in range(len(param_array.x)): reserve = param_array.x[np] epsilon = 0.00001 param_array.x[np] = reserve + epsilon hicx, hicy, hiflags, hipart_distance = self.parameter_based_model(self.params) parameter_nos = flex.int([self.frame_id_to_param_no[f] for f in self.frame_id]) functional_hi = self.compute_functional_only( tox = self.To_x, toy = self.To_y, spotcx = hicx, spotcy = hicy, spotfx = self.spotfx, spotfy = self.spotfy, master_tiles = self.master_tiles, frames = parameter_nos, part_distance = hipart_distance) param_array.x[np] = reserve - epsilon locx, locy, loflags, lopart_distance = self.parameter_based_model(self.params) functional_lo = self.compute_functional_only( tox = self.To_x, toy = self.To_y, spotcx = locx, spotcy = locy, spotfx = self.spotfx, spotfy = self.spotfy, master_tiles = self.master_tiles, frames = parameter_nos, part_distance = lopart_distance) #print "GRADIENT ",dist_parm," finite diff",(plus_funct-nega_funct)/(2.*epsilon),"analytical",newgrad[dist_parm] param_array.x[np]=reserve result.append( ( functional_hi - functional_lo )/(2.*epsilon) ) print("Setting fd grads", end=' ') for a in result: print("%8.3f"%a, end=' ') print() print(" on values", end=' ') for a in param_array.x: print("%8.3f"%a, end=' ') print() print(" cpp gradients", end=' ') for a in param_array.gradients: print("%8.3f"%a, end=' ') print() print() self.set_gradient_array(tag,result) def compute_functional_and_gradients(self): #print "HATTNE in compute_functional_and_gradients" self.from_x_array(self.x) self.cx, self.cy, self.flags, part_distance = self.parameter_based_model(self.params) #print "HATTNE in compute_functional_and_gradients", flex.mean(self.cx), flex.mean(self.cy), len(self.cx) #import sys #sys.exit(0) # HATTNE parameter_nos = flex.int([self.frame_id_to_param_no[f] for f in self.frame_id]) self.rezero_gradients_curvatures() self.set_refined_origins_to_c(self.FRAMES["refined_detector_origin"]) functional = self.compute_target( tox = self.To_x, toy = self.To_y, spotcx = self.cx.deep_copy(), spotcy = self.cy.deep_copy(), spotfx = self.spotfx, spotfy = self.spotfy, master_tiles = self.master_tiles, frames = parameter_nos, part_distance = part_distance) #self.compute_finite_difference_gradients_if_requested() gradients = self.get_gradient_array() self.c_curvatures = self.get_curvature_array() # print "CURVATURES", len(self.c_curvatures) # lst = list(self.c_curvatures) # print " block 1: ", lst[0:20] # print " block 2: ", lst[20:20 + 58] # print " block 3: ", lst[20 + 58:20 + 2 * 58] # print " block 4: ", lst[20 + 2* 58:20 + 3 * 58] print("Functional ",functional, math.sqrt(functional/self.cx.size())) return functional,gradients def radial_transverse_analysis(self): # very time consuming; should be recoded (C++?) SIGN = -1. PIXEL_SZ = 0.11 # mm/pixel zunit = col([0.,0.,1.]) self.frame_del_radial = {} self.frame_del_azimuthal = {} for x in range(len(self.frame_id)): frame_id = self.frame_id[x] frame_param_no = self.frame_id_to_param_no[frame_id] if frame_param_no >= self.n_refined_frames: continue if frame_id not in self.frame_del_radial: self.frame_del_radial[frame_id] = flex.double() self.frame_del_azimuthal[frame_id] = flex.double() correction_vector = col([self.correction_vector_x[x],self.correction_vector_y[x],0.]) position_vector = col([self.spotfx[x] - SIGN * self.FRAMES["detector_origin_x_refined"][frame_param_no]/PIXEL_SZ, self.spotfy[x] - SIGN * self.FRAMES["detector_origin_y_refined"][frame_param_no]/PIXEL_SZ, 0.]) position_unit = position_vector.normalize() transverse_unit = position_unit.cross(zunit) self.frame_del_radial[frame_id].append(correction_vector.dot(position_unit)) self.frame_del_azimuthal[frame_id].append(correction_vector.dot(transverse_unit)) def print_table(self): from libtbx import table_utils from libtbx.str_utils import format_value table_header = ["Tile","Dist","Nobs","aRmsd","Rmsd","delx","dely","disp","rotdeg", "Rsigma","Tsigma","Transx","Transy","DelRot","Rotdeg"] table_data = [] table_data.append(table_header) sort_radii = flex.sort_permutation(flex.double(self.radii)) tile_rmsds = flex.double() radial_sigmas = flex.double(len(self.tiles) // 4) tangen_sigmas = flex.double(len(self.tiles) // 4) wtaveg = [0.]*(len(self.tiles) // 4) for x in range(len(self.tiles) // 4): if self.tilecounts[x] >= 3: wtaveg[x] = self.weighted_average_angle_deg_from_tile(x, self.post_mean_cv[x], self.correction_vector_x, self.correction_vector_y) for idx in range(len(self.tiles) // 4): x = sort_radii[idx] if self.tilecounts[x] < 3: radial = (0,0) tangential = (0,0) rmean,tmean,rsigma,tsigma=(0,0,1,1) else: radial,tangential,rmean,tmean,rsigma,tsigma = get_radial_tangential_vectors(self,x, self.post_mean_cv[x], self.correction_vector_x, self.correction_vector_y, self.model_calcx-self.refined_cntr_x, self.model_calcy-self.refined_cntr_y) # paired rotations of two ASICS on the same sensor if x%2==0: # previous method: delrot = "%5.2f"%(wtaveg[x]-wtaveg[x+1]) delrot = "%5.2f"%(self.tile_rotations.x[x] - self.tile_rotations.x[1+x]) else: delrot = "" radial_sigmas[x]=rsigma tangen_sigmas[x]=tsigma table_data.append( [ format_value("%3d", x), format_value("%7.2f", self.radii[x]), format_value("%6d", self.tilecounts[x]), format_value("%5.2f", self.asymmetric_tile_rmsd[x]), format_value("%5.2f", self.tile_rmsd[x]), format_value("%5.2f", self.post_mean_cv[x][0]), format_value("%5.2f", self.post_mean_cv[x][1]), format_value("%5.2f", matrix.col(self.post_mean_cv[x]).length()), format_value("%6.2f", wtaveg[x]), format_value("%6.2f", rsigma), format_value("%6.2f", tsigma), format_value("%5.2f", self.tile_translations.x[2*x]), format_value("%5.2f", self.tile_translations.x[2*x+1]), copy.copy(delrot), format_value("%5.2f", self.tile_rotations.x[x]) ]) table_data.append([""]*len(table_header)) rstats = flex.mean_and_variance(radial_sigmas,self.tilecounts.as_double()) tstats = flex.mean_and_variance(tangen_sigmas,self.tilecounts.as_double()) table_data.append( [ format_value("%3s", "ALL"), format_value("%s", ""), format_value("%6d", self.overall_N), format_value("%5.2f", math.sqrt(flex.mean(self.delrsq))), format_value("%5.2f", self.overall_rmsd), format_value("%5.2f", self.overall_cv[0]), format_value("%5.2f", self.overall_cv[1]), format_value("%5.2f", flex.mean(flex.double([cv.length() for cv in self.post_mean_cv]))), format_value("%s", ""), format_value("%6.2f", rstats.mean()), format_value("%6.2f", tstats.mean()), format_value("%s", ""), format_value("%s", ""), #root mean squared difference in same-sensor (adjacent)-ASIC rotations, weighted by minimum # of observations on either ASIC of the sensor format_value("%5.2f", math.sqrt( flex.sum( flex.double([ (min([self.tilecounts[2*isen],self.tilecounts[2*isen+1]])) * (self.tile_rotations.x[2*isen] - self.tile_rotations.x[1+2*isen])**2 for isen in range(len(self.tiles) // 8)] ) )/ flex.sum( flex.double( [(min([self.tilecounts[2*isen],self.tilecounts[2*isen+1]])) for isen in range(len(self.tiles) // 8)] ) ) )), format_value("%s", ""), ]) print() print(table_utils.format(table_data,has_header=1,justify='center',delim=" ")) def print_table_2(self): from libtbx import table_utils from libtbx.str_utils import format_value table_header = ["Tile","Dist","Nobs","aRmsd","Rmsd","delx","dely","disp","rotdeg", "Rsigma","Tsigma","Transx","Transy","DelRot","Rotdeg"] table_data = [] table_data.append(table_header) sort_radii = flex.sort_permutation(flex.double(self.radii)) tile_rmsds = flex.double() radial_sigmas = flex.double(len(self.tiles) // 4) tangen_sigmas = flex.double(len(self.tiles) // 4) wtaveg = [0.]*(len(self.tiles) // 4) for x in range(len(self.tiles) // 4): if self.tilecounts[x] >= 3: wtaveg[x] = self.weighted_average_angle_deg_from_tile(x, self.post_mean_cv[x], self.correction_vector_x, self.correction_vector_y) def add_line_to_table(idx): x = sort_radii[idx] if self.tilecounts[x] < 3: radial = (0,0) tangential = (0,0) rmean,tmean,rsigma,tsigma=(0,0,1,1) else: radial,tangential,rmean,tmean,rsigma,tsigma = get_radial_tangential_vectors(self,x, self.post_mean_cv[x], self.correction_vector_x, self.correction_vector_y, self.model_calcx-self.refined_cntr_x, self.model_calcy-self.refined_cntr_y) table_data.append( [ format_value("%3d", x), format_value("%7.2f", self.radii[x]), format_value("%6d", self.tilecounts[x]), format_value("%5.2f", self.asymmetric_tile_rmsd[x]), format_value("%5.2f", self.tile_rmsd[x]), format_value("%5.2f", self.post_mean_cv[x][0]), format_value("%5.2f", self.post_mean_cv[x][1]), format_value("%5.2f", matrix.col(self.post_mean_cv[x]).length()), format_value("%6.2f", wtaveg[x]), format_value("%6.2f", rsigma), format_value("%6.2f", tsigma), format_value("%5.2f", self.tile_translations.x[2*x]), format_value("%5.2f", self.tile_translations.x[2*x+1]), "", format_value("%5.2f", self.tile_rotations.x[x]) ]) # order the printout by sensor, starting from innermost new_order = [] mutable = list(sort_radii) idx = 0 unit_translation_increments = flex.double(len(mutable)*2) while 1: if idx >= len(mutable): break if self.radii[mutable[idx]]==0.0: idx+=1; continue tile_select = mutable[idx] if tile_select%2 == 0: # even sensor_tiles = (tile_select, tile_select+1) sensor_ptrs = (idx, mutable.index(tile_select+1)) else: # odd sensor_tiles = (tile_select-1, tile_select) sensor_ptrs = ( mutable.index(tile_select-1), idx) if self.tilecounts[mutable[sensor_ptrs[0]]] + self.tilecounts[mutable[sensor_ptrs[1]]] < \ self.params.min_count: idx+=1 continue sum_weight = 0.0 sum_wt_x = 0.0 sum_wt_y = 0.0 for iptr, ptr in enumerate(sensor_ptrs): if ptr in new_order: break if self.tilecounts[mutable[ptr]] > 0: #print mutable[ptr] add_line_to_table (ptr) sum_weight += self.tilecounts[mutable[ptr]] sum_wt_x += self.tilecounts[mutable[ptr]] * self.tile_translations.x[2*mutable[ptr]] sum_wt_y += self.tilecounts[mutable[ptr]] * self.tile_translations.x[2*mutable[ptr]+1] new_order.append(ptr) if iptr==1: #print sensor_line = [""]*len(table_header) sensor_line[2]="%6d"%sum_weight sensor_line[11]="%5.2f"%round(sum_wt_x/sum_weight,0) sensor_line[12]="%5.2f"%round(sum_wt_y/sum_weight,0) unit_translation_increments[2*mutable[ptr]-2] = round(sum_wt_x/sum_weight,0) unit_translation_increments[2*mutable[ptr]-1] = round(sum_wt_y/sum_weight,0) unit_translation_increments[2*mutable[ptr]] = round(sum_wt_x/sum_weight,0) unit_translation_increments[2*mutable[ptr]+1] = round(sum_wt_y/sum_weight,0) table_data.append(sensor_line) table_data.append([""]*len(table_header)) idx+=1 if idx>=len(mutable): break print("Grouped by sensor, listing lowest Q-angle first:") print(table_utils.format(table_data,has_header=1,justify='center',delim=" ")) return unit_translation_increments def same_sensor_table(self,verbose=True): radii = flex.double() # from-instrument-center distance in pixels delrot= flex.double() # delta rotation in degrees meanrot=flex.double() # mean rotation in degrees weight= flex.double() # displacement = [] # vector between two same-sensor ASICS in pixels for x in range(len(self.tiles) // 8): delrot.append(self.tile_rotations.x[2*x] - self.tile_rotations.x[1+2*x]) meanrot.append(0.5*(self.tile_rotations.x[2*x] + self.tile_rotations.x[1+2*x])) radii.append((self.radii[2*x]+self.radii[2*x+1])/2) weight.append(min([self.tilecounts[2*x],self.tilecounts[2*x+1]])) displacement.append( col((self.To_x[2*x+1], self.To_y[2*x+1])) -col((self.tile_translations.x[2*(2*x+1)], self.tile_translations.x[2*(2*x+1)+1])) -col((self.To_x[2*x], self.To_y[2*x])) +col((self.tile_translations.x[2*(2*x)], self.tile_translations.x[2*(2*x)+1])) ) unrotated_displacement = [] # same, except correct for the off-square rotation of this sensor for i,a in enumerate(displacement): corrected_a = a.rotate_2d(angle=meanrot[i],deg=True) while (corrected_a[0] < 0. or abs(corrected_a[1]) > abs(corrected_a[0])): corrected_a = corrected_a.rotate_2d(angle=90., deg=True) unrotated_displacement.append( corrected_a ) order = flex.sort_permutation(radii) if verbose: for x in order: print("%02d %02d %5.0f"%(2*x,2*x+1,weight[x]), end=' ') print("%6.1f"%radii[x], end=' ') print("%5.2f"%(delrot[x]), end=' ') print("%6.3f"%(displacement[x].length()-194.), end=' ') # ASIC is 194; just print gap #print " %6.3f"%(self.tile_distances.x[x]) print("lateral %7.3f transverse %7.3f pix"%(unrotated_displacement[x][0], unrotated_displacement[x][1])) stats = flex.mean_and_variance(flex.double([t.length()-194. for t in displacement]),weight) print(" sensor gap is %7.3f px +/- %7.3f"%(stats.mean(), stats.gsl_stats_wsd())) stats = flex.mean_and_variance(flex.double([t[0] for t in unrotated_displacement]),weight) print("lateral gap is %7.3f px +/- %7.3f"%(stats.mean(), stats.gsl_stats_wsd())) stats = flex.mean_and_variance(flex.double([t[1] for t in unrotated_displacement]),weight) print("transverse gap is %7.3f px +/- %7.3f"%(stats.mean(), stats.gsl_stats_wsd())) @staticmethod def print_unit_translations(data, params, optional): from scitbx.array_family import flex def pretty_format(data): out = """""" for quad in [0,1,2,3]: for blockof2 in [0,1,2,3]: format = "%3.0f,"*8 if quad==3 and blockof2==3: format = format[0:-1] format = " %s"%format out+=format+""" """ if quad<3: out += """ """ # reality check here in case the PAD is not 64-tiles Nparam = len(data) decoration = out.split("%3.0f,") if len(decoration)>Nparam+1: decoration = decoration[len(decoration)-Nparam:] return "%3.0f,".join(decoration) return out from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract if params.detector_format_version is not None: base_arguments = ["distl.detector_format_version=%s"%params.detector_format_version] if optional is not None: if optional.distl.quad_translations is not None: base_arguments.append("distl.quad_translations="+",".join([str(s) for s in optional.distl.quad_translations])) if optional.distl.tile_translations is not None: base_arguments.append("distl.tile_translations="+",".join([str(s) for s in optional.distl.tile_translations])) stuff = cxi_versioned_extract(base_arguments) old = flex.double(stuff.distl.tile_translations) print("cctbx already defines unit pixel translations for detector format version %s:"%params.detector_format_version) print(pretty_format(old)%tuple(old)) print("new unit pixel increments will be SUBTRACTED off these to get final translations") print() else: print("no pre-existing translations were input") print() old = flex.double(128) print("Unit translations to be pasted into spotfinder/applications/xfel/cxi_phil.py:") new = old - flex.double(data) #overall_format = """ working_extract.distl.tile_translations = [ overall_format = '''distl {\n tile_translations = """ '''+pretty_format(new)+''' """}''' print(overall_format%tuple(new)) def run_cycle_a(self): self.bandpass_models = {} #print "HATTNE MARKER #0" lbfgs_with_curvatures_mix_in.__init__(self, min_iterations=0, max_iterations=1000, traditional_convergence_test_eps=1.0, # new for LD91; to shorten the run time use_curvatures=True) #print "HATTNE MARKER #1" C = self C.post_min_recalc() #import sys #sys.exit(0) # HATTNE C.print_table() unit_translations = C.print_table_2() self.print_unit_translations(unit_translations, self.params, self.optional_params) #import sys #sys.exit(0) # HATTNE sum_sq = 0. for key in C.frame_delx.keys(): param_no = C.frame_id_to_param_no[key] if param_no >= C.n_refined_frames:continue mn_x = flex.mean(C.frame_delx[key]) mn_y = flex.mean(C.frame_dely[key]) print("frame %4d count %4d delx %7.2f dely %7.2f"%(key, len(C.frame_delx[key]), mn_x, mn_y ), end=' ') sum_sq += mn_x*mn_x + mn_y*mn_y if param_no