Exemplo n.º 1
0
  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()
Exemplo n.º 2
0
 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)
Exemplo n.º 3
0
  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)
Exemplo n.º 4
0
Arquivo: mark3.py Projeto: dials/cctbx
    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)
Exemplo n.º 5
0
 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)