Ejemplo n.º 1
0
def get_fmodel_from_pdb(pdb_file_name,
                        algorithm="direct",
                        d_min=2.0,
                        target="ls_wunit_k1"):
    pdb_file = libtbx.env.find_in_repositories(
        relative_path="phenix_regression/pdb/%s" % pdb_file_name,
        test=os.path.isfile)
    xray_structure = iotbx.pdb.input(
        file_name=pdb_file).xray_structure_simple()
    params = mmtbx.command_line.fmodel.fmodel_from_xray_structure_master_params.extract(
    )
    assert params.high_resolution is None
    assert params.scattering_table == 'n_gaussian'
    assert params.structure_factors_accuracy.algorithm == 'fft'
    params.high_resolution = d_min
    params.scattering_table = "wk1995"
    params.structure_factors_accuracy.algorithm = algorithm
    fmodel = mmtbx.utils.fmodel_from_xray_structure(
        xray_structure=xray_structure,
        params=params,
        target=target,
        r_free_flags_fraction=0.01).fmodel
    assert approx_equal(
        mmtbx.bulk_solvent.r_factor(fmodel.f_obs().data(),
                                    fmodel.f_model().data()), 0)
    sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
    sfg_params.algorithm = algorithm
    fmodel = mmtbx.f_model.manager(target_name=target,
                                   xray_structure=xray_structure,
                                   f_obs=abs(fmodel.f_model()),
                                   sf_and_grads_accuracy_params=sfg_params)
    assert approx_equal(fmodel.r_work(), 0)
    return fmodel
Ejemplo n.º 2
0
def get_fmodel_from_pdb(pdb_file_name,
                        algorithm = "direct",
                        d_min = 2.0,
                        target = "ls_wunit_k1"):
  pdb_file = libtbx.env.find_in_repositories(
    relative_path="phenix_regression/pdb/%s"%pdb_file_name,test=os.path.isfile)
  xray_structure = iotbx.pdb.input(file_name =pdb_file).xray_structure_simple()
  params = mmtbx.command_line.fmodel.fmodel_from_xray_structure_master_params.extract()
  assert params.high_resolution is None
  assert params.scattering_table == 'n_gaussian'
  assert params.structure_factors_accuracy.algorithm == 'fft'
  params.high_resolution = d_min
  params.scattering_table = "wk1995"
  params.structure_factors_accuracy.algorithm = algorithm
  fmodel = mmtbx.utils.fmodel_from_xray_structure(
    xray_structure        = xray_structure,
    params                = params,
    target                = target,
    r_free_flags_fraction = 0.01).fmodel
  assert approx_equal(mmtbx.bulk_solvent.r_factor(fmodel.f_obs().data(),
    fmodel.f_model().data()), 0)
  sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
  sfg_params.algorithm = algorithm
  fmodel = mmtbx.f_model.manager(
    target_name    = target,
    xray_structure = xray_structure,
    f_obs          = abs(fmodel.f_model()),
    sf_and_grads_accuracy_params = sfg_params)
  assert approx_equal(fmodel.r_work(), 0)
  return fmodel
Ejemplo n.º 3
0
  def scaling_metrics(self,other):
    # Read reflections
    # some requirements. 1) Fobs scaled to Fcalc, not the other way around.
    # 2) ability to make a plot of the two scaled sets
    # 3) set the number of bins
    # 4) understand and print out the per-bin scaling factor
    # 5) print an overall stats line at the end of the table
    # 6) choose one or the other binnings
    """1) scaling and analysis are separate functions"""

    #f_obs, r_free_flags = f_obs.common_sets(r_free_flags)
    f_obs = other
    #r_free_flags = r_free_flags.array(data=r_free_flags.data()==1)
    # Read model

    # Get Fmodel
    fmodel = mmtbx.f_model.manager(
      f_obs          = f_obs,
      #r_free_flags   = r_free_flags,
      xray_structure = self.xray_structure)
    # Do anisotropic overall scaling, bulk-solvent modeling, outlier rejection
    #fmodel.update_all_scales()
    print "r_work, r_free: %6.4f, %6.4f"%(fmodel.r_work(), fmodel.r_free())
    # Print statistics in resolution bins
    f_model = fmodel.f_model_scaled_with_k1()
    bin_selections = fmodel.f_obs().log_binning()
    dsd = fmodel.f_obs().d_spacings().data()
    print "Bin# Resolution    Nref Cmpl  Rw     CC"
    fmt="%2d: %6.3f-%-6.3f %5d %5.3f %6.4f %6.4f"
    for i_bin, sel in enumerate(bin_selections):
      d           = dsd.select(sel)
      d_min       = flex.min(d)
      d_max       = flex.max(d)
      fmodel_sel  = fmodel.select(sel)
      n           = d.size()
      f_obs_sel   = fmodel.f_obs().select(sel)
      f_model_sel = abs(f_model.select(sel)).data()
      cmpl        = f_obs_sel.completeness(d_max=d_max)
      r_work      = fmodel_sel.r_work()
      cc          = flex.linear_correlation(x=f_obs_sel.data(),
                    y=f_model_sel).coefficient()
      print fmt%(i_bin, d_max, d_min, n, cmpl, r_work, cc)
    # Alternative binning
    print
    print "Bin# Resolution    Nref Cmpl  Rw     CC"
    fmodel.f_obs().setup_binner(reflections_per_bin = 2500)
    f_model.use_binning_of(fmodel.f_obs())
    for i_bin in fmodel.f_obs().binner().range_used():
      sel = fmodel.f_obs().binner().selection(i_bin)
      d           = dsd.select(sel)
      d_min       = flex.min(d)
      d_max       = flex.max(d)
      fmodel_sel  = fmodel.select(sel)
      n           = d.size()
      f_obs_sel   = fmodel.f_obs().select(sel)
      f_model_sel = abs(f_model.select(sel)).data()
      cmpl        = f_obs_sel.completeness(d_max=d_max)
      r_work      = fmodel_sel.r_work()
      cc          = flex.linear_correlation(x=f_obs_sel.data(),
                    y=f_model_sel).coefficient()
      print fmt%(i_bin, d_max, d_min, n, cmpl, r_work, cc)
Ejemplo n.º 4
0
    def scaling_metrics(self, other):
        # Read reflections
        # some requirements. 1) Fobs scaled to Fcalc, not the other way around.
        # 2) ability to make a plot of the two scaled sets
        # 3) set the number of bins
        # 4) understand and print out the per-bin scaling factor
        # 5) print an overall stats line at the end of the table
        # 6) choose one or the other binnings
        """1) scaling and analysis are separate functions"""

        #f_obs, r_free_flags = f_obs.common_sets(r_free_flags)
        f_obs = other
        #r_free_flags = r_free_flags.array(data=r_free_flags.data()==1)
        # Read model

        # Get Fmodel
        fmodel = mmtbx.f_model.manager(
            f_obs=f_obs,
            #r_free_flags   = r_free_flags,
            xray_structure=self.xray_structure)
        # Do anisotropic overall scaling, bulk-solvent modeling, outlier rejection
        #fmodel.update_all_scales()
        print "r_work, r_free: %6.4f, %6.4f" % (fmodel.r_work(),
                                                fmodel.r_free())
        # Print statistics in resolution bins
        f_model = fmodel.f_model_scaled_with_k1()
        bin_selections = fmodel.f_obs().log_binning()
        dsd = fmodel.f_obs().d_spacings().data()
        print "Bin# Resolution    Nref Cmpl  Rw     CC"
        fmt = "%2d: %6.3f-%-6.3f %5d %5.3f %6.4f %6.4f"
        for i_bin, sel in enumerate(bin_selections):
            d = dsd.select(sel)
            d_min = flex.min(d)
            d_max = flex.max(d)
            fmodel_sel = fmodel.select(sel)
            n = d.size()
            f_obs_sel = fmodel.f_obs().select(sel)
            f_model_sel = abs(f_model.select(sel)).data()
            cmpl = f_obs_sel.completeness(d_max=d_max)
            r_work = fmodel_sel.r_work()
            cc = flex.linear_correlation(x=f_obs_sel.data(),
                                         y=f_model_sel).coefficient()
            print fmt % (i_bin, d_max, d_min, n, cmpl, r_work, cc)
        # Alternative binning
        print
        print "Bin# Resolution    Nref Cmpl  Rw     CC"
        fmodel.f_obs().setup_binner(reflections_per_bin=2500)
        f_model.use_binning_of(fmodel.f_obs())
        for i_bin in fmodel.f_obs().binner().range_used():
            sel = fmodel.f_obs().binner().selection(i_bin)
            d = dsd.select(sel)
            d_min = flex.min(d)
            d_max = flex.max(d)
            fmodel_sel = fmodel.select(sel)
            n = d.size()
            f_obs_sel = fmodel.f_obs().select(sel)
            f_model_sel = abs(f_model.select(sel)).data()
            cmpl = f_obs_sel.completeness(d_max=d_max)
            r_work = fmodel_sel.r_work()
            cc = flex.linear_correlation(x=f_obs_sel.data(),
                                         y=f_model_sel).coefficient()
            print fmt % (i_bin, d_max, d_min, n, cmpl, r_work, cc)