def run(space_group_info):
  """
  Make sure it work for all space groups and boxes with non-zero origin.
  """
  # make up data
  xrs = random_structure.xray_structure(
    space_group_info       = space_group_info,
    volume_per_atom        = 50,
    general_positions_only = False,
    u_iso                  = 0.3,
    elements               = ('C', 'N', 'O', "S")*10,
    min_distance           = 1.5)
  xrs.scattering_type_registry(table="wk1995")
  f_calc = xrs.structure_factors(d_min=2).f_calc()
  f_obs = abs(f_calc)
  # create fmodel object
  fmodel = mmtbx.f_model.manager(
    xray_structure = xrs,
    f_obs          = f_obs)
  fmodel.update_all_scales()
  mc1 = fmodel.electron_density_map().map_coefficients(
      map_type     = "2mFo-DFc",
      isotropize   = False,
      exclude_free_r_reflections=False,
      fill_missing = False)
  crystal_gridding = fmodel.f_obs().crystal_gridding(
    d_min             = fmodel.f_obs().d_min(),
    symmetry_flags    = maptbx.use_space_group_symmetry,
    resolution_factor = 1./3)
  # compute OMIT map
  r = cfom.run(
    crystal_gridding    = crystal_gridding,
    fmodel              = fmodel.deep_copy(),
    full_resolution_map = False,
    max_boxes           = 70,
    neutral_volume_box_cushion_width = 0,
    box_size_as_fraction=0.3,
    log=False)
  ccs = get_cc(mc1=mc1, mc2=r.map_coefficients(filter_noise=False), xrs=xrs)
  assert flex.mean(ccs) > 0.8
  print("  CC(min/max,mean)",ccs.min_max_mean().as_tuple())
def run(space_group_info):
  """
  Make sure it work for all space groups and boxes with non-zero origin.
  """
  # make up data
  xrs = random_structure.xray_structure(
    space_group_info       = space_group_info,
    volume_per_atom        = 50,
    general_positions_only = False,
    u_iso                  = 0.3,
    elements               = ('C', 'N', 'O', "S")*10,
    min_distance           = 1.5)
  xrs.scattering_type_registry(table="wk1995")
  f_calc = xrs.structure_factors(d_min=2).f_calc()
  f_obs = abs(f_calc)
  # create fmodel object
  fmodel = mmtbx.f_model.manager(
    xray_structure = xrs,
    f_obs          = f_obs)
  fmodel.update_all_scales()
  mc1 = fmodel.electron_density_map().map_coefficients(
      map_type     = "2mFo-DFc",
      isotropize   = False,
      exclude_free_r_reflections=False,
      fill_missing = False)
  crystal_gridding = fmodel.f_obs().crystal_gridding(
    d_min             = fmodel.f_obs().d_min(),
    symmetry_flags    = maptbx.use_space_group_symmetry,
    resolution_factor = 1./3)
  # compute OMIT map
  r = cfom.run(
    crystal_gridding    = crystal_gridding,
    fmodel              = fmodel.deep_copy(),
    full_resolution_map = False,
    max_boxes           = 70,
    neutral_volume_box_cushion_width = 0,
    box_size_as_fraction=0.3,
    log=False)
  ccs = get_cc(mc1=mc1, mc2=r.map_coefficients(filter_noise=False), xrs=xrs)
  assert flex.mean(ccs) > 0.8
  print "  CC(min/max,mean)",ccs.min_max_mean().as_tuple()
def run():
    """
  This test makes sure that composite full omit maps calculated using Marat's
  ASU map code and not using ASU maps exactly match.
  """
    # make up data
    xrs = random_structure.xray_structure(
        space_group_info=space_group_info("P 1"),
        volume_per_atom=250,
        general_positions_only=False,
        elements=('C', 'N', 'O', "S") * 50,
        u_iso=0.1,
        min_distance=1.0)
    xrs.scattering_type_registry(table="wk1995")
    f_obs = abs(xrs.structure_factors(d_min=2).f_calc())
    # create fmodel object
    xrs.shake_sites_in_place(mean_distance=0.3)
    sel = xrs.random_remove_sites_selection(fraction=0.1)
    xrs = xrs.select(sel)
    fmodel = mmtbx.f_model.manager(xray_structure=xrs, f_obs=f_obs)
    fmodel.update_all_scales(update_f_part1=False)
    crystal_gridding = fmodel.f_obs().crystal_gridding(
        d_min=fmodel.f_obs().d_min(),
        symmetry_flags=maptbx.use_space_group_symmetry,
        resolution_factor=0.25)
    # compute OMIT maps
    r1 = omit_p1_specific(crystal_gridding=crystal_gridding,
                          fmodel=fmodel.deep_copy(),
                          max_boxes=70,
                          map_type="Fo")
    r2 = omit_general_obsolete(crystal_gridding=crystal_gridding,
                               fmodel=fmodel.deep_copy(),
                               full_resolution_map=False,
                               map_type="Fo",
                               n_debias_cycles=1,
                               neutral_volume_box_cushion_width=0,
                               box_size_as_fraction=0.3,
                               max_boxes=70,
                               log=sys.stdout)
    r3 = cfom.run(crystal_gridding=crystal_gridding,
                  fmodel=fmodel.deep_copy(),
                  full_resolution_map=False,
                  neutral_volume_box_cushion_width=0,
                  box_size_as_fraction=0.3,
                  max_boxes=70,
                  log=sys.stdout)
    assert approx_equal(r1.r, r2.r)

    def r_factor(x, y):
        x = flex.abs(abs(x).data())
        y = flex.abs(abs(y).data())
        sc = flex.sum(x * y) / flex.sum(y * y)
        return flex.sum(flex.abs(x - sc * y)) / flex.sum(x + sc * y) * 2

    print(abs(r1.map_coefficients).data().min_max_mean().as_tuple())
    print(abs(r2.map_coefficients).data().min_max_mean().as_tuple())
    cc1 = flex.linear_correlation(
        x=abs(r1.map_coefficients).data(),
        y=abs(r2.map_coefficients).data()).coefficient()
    assert approx_equal(cc1, 1.0)
    cc2 = flex.linear_correlation(
        x=abs(r1.map_coefficients).data(),
        y=abs(r3.map_coefficients(filter_noise=False)).data()).coefficient()
    assert cc2 > 0.8, cc2
    assert approx_equal(r_factor(x=r1.map_coefficients, y=r2.map_coefficients),
                        0.0)
    cc3 = flex.linear_correlation(x=r1.r, y=r3.r).coefficient()
    assert cc3 > 0.95
    for cutoff in [0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99]:
        print(
            maptbx.cc_peak(
                cutoff=cutoff,
                map_coeffs_1=r1.map_coefficients,
                map_coeffs_2=r3.map_coefficients(filter_noise=False)),
            "CCpeak", cutoff)
def run():
  """
  This test makes sure that composite full omit maps calculated using Marat's
  ASU map code and not using ASU maps exactly match.
  """
  # make up data
  xrs = random_structure.xray_structure(
    space_group_info       = space_group_info("P 1"),
    volume_per_atom        = 250,
    general_positions_only = False,
    elements               = ('C', 'N', 'O', "S")*50,
    u_iso                  = 0.1,
    min_distance           = 1.0)
  xrs.scattering_type_registry(table="wk1995")
  f_obs = abs(xrs.structure_factors(d_min=2).f_calc())
  # create fmodel object
  xrs.shake_sites_in_place(mean_distance=0.3)
  sel = xrs.random_remove_sites_selection(fraction=0.1)
  xrs = xrs.select(sel)
  fmodel = mmtbx.f_model.manager(
    xray_structure = xrs,
    f_obs          = f_obs)
  fmodel.update_all_scales(update_f_part1=False)
  crystal_gridding = fmodel.f_obs().crystal_gridding(
    d_min             = fmodel.f_obs().d_min(),
    symmetry_flags    = maptbx.use_space_group_symmetry,
    resolution_factor = 0.25)
  # compute OMIT maps
  r1 = omit_p1_specific(
    crystal_gridding = crystal_gridding,
    fmodel           = fmodel.deep_copy(),
    max_boxes=70,
    map_type         = "Fo")
  r2 = omit_general_obsolete(
    crystal_gridding = crystal_gridding,
    fmodel           = fmodel.deep_copy(),
    full_resolution_map = False,
    map_type         = "Fo",
    n_debias_cycles  = 1,
    neutral_volume_box_cushion_width = 0,
    box_size_as_fraction=0.3,
    max_boxes=70,
    log=sys.stdout)
  r3 = cfom.run(
    crystal_gridding = crystal_gridding,
    fmodel           = fmodel.deep_copy(),
    full_resolution_map = False,
    neutral_volume_box_cushion_width = 0,
    box_size_as_fraction=0.3,
    max_boxes=70,
    log=sys.stdout)
  assert approx_equal(r1.r, r2.r)
  def r_factor(x,y):
    x = flex.abs(abs(x).data())
    y = flex.abs(abs(y).data())
    sc = flex.sum(x*y)/flex.sum(y*y)
    return flex.sum(flex.abs(x-sc*y))/flex.sum(x+sc*y)*2
  print abs(r1.map_coefficients).data().min_max_mean().as_tuple()
  print abs(r2.map_coefficients).data().min_max_mean().as_tuple()
  cc1=flex.linear_correlation(
      x=abs(r1.map_coefficients).data(),
      y=abs(r2.map_coefficients).data()).coefficient()
  assert approx_equal(cc1, 1.0)
  cc2=flex.linear_correlation(
      x=abs(r1.map_coefficients).data(),
      y=abs(r3.map_coefficients(filter_noise=False)).data()).coefficient()
  assert cc2 > 0.8, cc2
  assert approx_equal(r_factor(
    x=r1.map_coefficients, y=r2.map_coefficients), 0.0)
  cc3=flex.linear_correlation(x=r1.r, y=r3.r).coefficient()
  assert cc3>0.95
  for cutoff in [0.5,0.6,0.7,0.8,0.9,0.95,0.99]:
    print maptbx.cc_peak(
      cutoff       = cutoff,
      map_coeffs_1 = r1.map_coefficients,
      map_coeffs_2 = r3.map_coefficients(filter_noise=False)), "CCpeak", cutoff