def __init__(self,params):
correction_vectors.__init__(self)
self.read_data(params)
self.x = flex.double([0.]*128) # x & y displacements for each of 64 tiles
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
use_curvatures=True)
def __init__(self,xcoord,ycoord,rij_matrix,wij_matrix,verbose):
self.verbose = verbose
self.x = xcoord.concatenate(ycoord)
self.NN = len(xcoord)
self.rij_matrix = rij_matrix
self.wij_matrix = wij_matrix
if self.verbose:print len(self.x)
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
traditional_convergence_test_eps=1.0,
use_curvatures=True)
def __init__(self,xcoord,ycoord,rij_matrix,wij_matrix,verbose):
self.verbose = verbose
self.x = xcoord.concatenate(ycoord)
self.NN = len(xcoord)
self.rij_matrix = rij_matrix
self.wij_matrix = wij_matrix
if self.verbose:print(len(self.x))
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
traditional_convergence_test_eps=1.0,
use_curvatures=True)
def __init__(self,params):
self.bandpass_models = {}
correction_vectors.__init__(self)
#self.nominal_tile_centers(params.effective_tile_boundaries)
self.read_data(params)
self.params = params
self.x = flex.double([0.]*(len(self.tiles) // 2)+[0.]*(len(self.tiles) // 4)) # x & y displacements for each of 64 tiles
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
use_curvatures=True)
def __init__(self, params):
self.bandpass_models = {}
correction_vectors.__init__(self)
#self.nominal_tile_centers(params.effective_tile_boundaries)
self.read_data(params)
self.params = params
self.x = flex.double(
[0.] * (len(self.tiles) // 2) + [0.] *
(len(self.tiles) // 4)) # x & y displacements for each of 64 tiles
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
use_curvatures=True)
def __init__(self,xcoord,ycoord):
self.xcoord = xcoord
self.ycoord = ycoord
self.x = flex.double([0])
from scitbx.matrix import col
self.center_of_mass = col((flex.mean(self.xcoord), flex.mean(self.ycoord)))
grid = [ self.functional_only(t*math.pi/180.) for t in xrange(0,180,5) ]
minvalue = min(grid)
self.x = flex.double([5*grid.index(minvalue)*math.pi/180.])
#print "grid_minimum",list(self.x)
# XXX Looks like LBFGS is not performing minimization; investigate later
# XXX can probably return here; 5-degree granularity enough; no need for LBFGS
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
use_curvatures=False)
def __init__(self,xcoord,ycoord):
self.xcoord = xcoord
self.ycoord = ycoord
self.x = flex.double([0])
from scitbx.matrix import col
self.center_of_mass = col((flex.mean(self.xcoord), flex.mean(self.ycoord)))
grid = [ self.functional_only(t*math.pi/180.) for t in range(0,180,5) ]
minvalue = min(grid)
self.x = flex.double([5*grid.index(minvalue)*math.pi/180.])
#print "grid_minimum",list(self.x)
# XXX Looks like LBFGS is not performing minimization; investigate later
# XXX can probably return here; 5-degree granularity enough; no need for LBFGS
lbfgs_with_curvatures_mix_in.__init__(self,
min_iterations=0,
max_iterations=1000,
use_curvatures=False)
def __init__(self, x_obs, y_obs, w_obs, initial, use_curvatures=False):
assert x_obs.size() == y_obs.size()
self.x_obs = x_obs
self.y_obs = y_obs
self.w_obs = w_obs #flex.double([1.0]*(w_obs.size()))
self.n = len(initial)
self.x = initial.deep_copy()
# self.minimizer = scitbx.lbfgs.run(target_evaluator=self,
# termination_params = scitbx.lbfgs.termination_parameters
# (traditional_convergence_test_eps=1.e-10, min_iterations=0), core_params =
# scitbx.lbfgs.core_parameters(gtol=0.00011), log=sys.stdout)
lbfgs_with_curvatures_mix_in.__init__(
self,
min_iterations=0,
max_iterations=1000,
traditional_convergence_test_eps=1e-10,
use_curvatures=use_curvatures)
self.a = self.x
def __init__(self, use_curvatures=True, *args, **kwargs):
LBFGSsolver.__init__(self, *args, **kwargs)
if self.IAprm_truth is not None:
self.IAprm_truth = flex.log(self.IAprm_truth)
self.IBprm_truth = flex.log(self.IBprm_truth)
#self.Gprm_truth = flex.log(self.Gprm_truth)
IAx = flex.log(self.x[:self.Nhkl])
IBx = flex.log(self.x[self.Nhkl:2 * self.Nhkl])
Gx = self.x[2 * self.Nhkl:]
#Gx = flex.log(self.x[2*self.Nhkl:])
self.x = IAx.concatenate(IBx)
self.x = self.x.concatenate(Gx)
if use_curvatures:
self.minimizer = lbfgs_with_curvatures_mix_in.__init__(
self,
min_iterations=0,
max_iterations=None,
use_curvatures=True)
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 ),
sum_sq += mn_x*mn_x + mn_y*mn_y
if param_no<C.n_refined_frames:
print "%7.2f %7.2f"%(C.frame_translations.x[2*param_no],C.frame_translations.x[1+2*param_no])
else: print "N/A"
displacement = math.sqrt(sum_sq / len(C.frame_delx.keys()))
print "rms displacement of frames %7.2f"%displacement
C.detector_origin_analysis()
C.radial_transverse_analysis()
sum_sq_r = 0.
sum_sq_a = 0.
for key in C.frame_del_radial.keys():
mn_r = flex.mean(C.frame_del_radial[key])
mn_a = flex.mean(C.frame_del_azimuthal[key])
print "frame %4d count %4d delrad %7.2f delazi %7.2f"%(key,
len(C.frame_del_radial[key]),
mn_r,
mn_a ),
sum_sq_r += mn_r*mn_r
sum_sq_a += mn_a*mn_a
param_no = C.frame_id_to_param_no[key]
print "deldist %7.3f mm"%C.frame_distances.x[param_no],
print "distance %7.3f mm"%(
C.frame_distances.x[param_no] +
C.FRAMES["distance"][param_no]),
print "rotz_deg=%6.2f"%( (180./math.pi)*C.frame_rotz.x[param_no] )
print "rms radial displacement %7.2f"%(math.sqrt(sum_sq_r/len(C.frame_del_radial.keys())))
print "rms azimut displacement %7.2f"%(math.sqrt(sum_sq_a/len(C.frame_del_radial.keys())))
C.same_sensor_table()
print "Cycle A translations & rotations"
print {"translations": list(self.tile_translations.x),
"rotations": list(self.tile_rotations.x)}
print "integration {"
print " subpixel_joint_model{"
print "rotations= \\"
for irot in xrange(len(self.tile_rotations.x)):
print " %11.8f "%self.tile_rotations.x[irot],
if irot%4==3 and irot!=len(self.tile_rotations.x)-1: print "\\"
print
print "translations= \\"
for irot in xrange(len(self.tile_translations.x)):
print " %11.8f"%self.tile_translations.x[irot],
if irot%4==3 and irot!=len(self.tile_translations.x)-1: print "\\"
print
print " }"
print "}"
print
def __init__(self, params):
correction_vectors.__init__(self)
self.read_data(params)
self.x = flex.double([0.0] * 128) # x & y displacements for each of 64 tiles
lbfgs_with_curvatures_mix_in.__init__(self, min_iterations=0, max_iterations=1000, use_curvatures=True)
