def check_f_calc_derivs(): eps = 1e-6 g_fin = flex.complex_double() c_fin = flex.vec3_double() for ih in xrange(f_calc.size()): c_orig = f_calc[ih] g_fin_ab = [] c_fin_ab = [] for iab in [0, 1]: fs = [] gs = [] for signed_eps in [eps, -eps]: if iab == 0: f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag) else: f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps) trg_eps = r1.target(f_obs=f_obs, f_calc=f_calc) fs.append(trg_eps.t) gs.append(trg_eps.f_calc_gradients[ih]) g_fin_ab.append((fs[0] - fs[1]) / (2 * eps)) c_fin_ab.append((gs[0] - gs[1]) / (2 * eps)) g_fin.append(complex(*g_fin_ab)) assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real) c_fin.append((c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag)) f_calc[ih] = c_orig for pn, f, a in zip(g_fin.part_names(), g_fin.parts(), trg.f_calc_gradients.parts()): print >> log, "g fin %s:" % pn, numstr(f) print >> log, " ana %s:" % pn, numstr(a) assert approx_equal(trg.f_calc_gradients, g_fin) for pn, f, a in zip(["aa", "bb", "ab"], c_fin.parts(), trg.f_calc_hessians.parts()): print >> log, "c fin %s:" % pn, numstr(f) print >> log, " ana %s:" % pn, numstr(a) assert approx_equal(trg.f_calc_hessians, c_fin)
def check_f_calc_derivs(): eps = 1e-6 g_fin = flex.complex_double() c_fin = flex.vec3_double() for ih in xrange(f_calc.size()): c_orig = f_calc[ih] g_fin_ab = [] c_fin_ab = [] for iab in [0,1]: fs = [] gs = [] for signed_eps in [eps, -eps]: if (iab == 0): f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag) else: f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps) trg_eps = r1.target(f_obs=f_obs, f_calc=f_calc) fs.append(trg_eps.t) gs.append(trg_eps.f_calc_gradients[ih]) g_fin_ab.append((fs[0]-fs[1])/(2*eps)) c_fin_ab.append((gs[0]-gs[1])/(2*eps)) g_fin.append(complex(*g_fin_ab)) assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real) c_fin.append((c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag)) f_calc[ih] = c_orig for pn,f,a in zip( g_fin.part_names(), g_fin.parts(), trg.f_calc_gradients.parts()): print >> log, "g fin %s:" % pn, numstr(f) print >> log, " ana %s:" % pn, numstr(a) assert approx_equal(trg.f_calc_gradients, g_fin) for pn,f,a in zip( ["aa", "bb", "ab"], c_fin.parts(), trg.f_calc_hessians.parts()): print >> log, "c fin %s:" % pn, numstr(f) print >> log, " ana %s:" % pn, numstr(a) assert approx_equal(trg.f_calc_hessians, c_fin)
def check_f_calc_abs_derivs(): eps = 1e-6 g_fin = flex.double() c_fin = flex.double() for ih in range(f_calc_abs.size()): fs = [] gs = [] c_orig = f_calc_abs[ih] for signed_eps in [eps, -eps]: f_calc_abs[ih] = c_orig + signed_eps trg_eps = r1.target(f_obs=f_obs, f_calc_abs=f_calc_abs) fs.append(trg_eps.t) gs.append(trg_eps.g[ih]) g_fin.append((fs[0] - fs[1]) / (2 * eps)) c_fin.append((gs[0] - gs[1]) / (2 * eps)) f_calc_abs[ih] = c_orig print("g fin:", numstr(g_fin), file=log) print(" ana:", numstr(trg.g), file=log) assert approx_equal(trg.g, g_fin) print("c fin:", numstr(c_fin), file=log) print(" ana:", numstr(trg.c), file=log) assert approx_equal(trg.c, c_fin)
def check_f_calc_abs_derivs(): eps = 1e-6 g_fin = flex.double() c_fin = flex.double() for ih in xrange(f_calc_abs.size()): fs = [] gs = [] c_orig = f_calc_abs[ih] for signed_eps in [eps, -eps]: f_calc_abs[ih] = c_orig + signed_eps trg_eps = r1.target(f_obs=f_obs, f_calc_abs=f_calc_abs) fs.append(trg_eps.t) gs.append(trg_eps.g[ih]) g_fin.append((fs[0] - fs[1]) / (2 * eps)) c_fin.append((gs[0] - gs[1]) / (2 * eps)) f_calc_abs[ih] = c_orig print >> log, "g fin:", numstr(g_fin) print >> log, " ana:", numstr(trg.g) assert approx_equal(trg.g, g_fin) print >> log, "c fin:", numstr(c_fin) print >> log, " ana:", numstr(trg.c) assert approx_equal(trg.c, c_fin)
def exercise(mt, n_refl, log): f_obs = mt.random_double(size=n_refl) f_calc = flex.complex_double(mt.random_double(size=f_obs.size()), mt.random_double(size=f_obs.size())) f_calc_abs = flex.abs(f_calc) trg = r1.target(f_obs=f_obs, f_calc=f_calc) def check_f_calc_abs_derivs(): eps = 1e-6 g_fin = flex.double() c_fin = flex.double() for ih in range(f_calc_abs.size()): fs = [] gs = [] c_orig = f_calc_abs[ih] for signed_eps in [eps, -eps]: f_calc_abs[ih] = c_orig + signed_eps trg_eps = r1.target(f_obs=f_obs, f_calc_abs=f_calc_abs) fs.append(trg_eps.t) gs.append(trg_eps.g[ih]) g_fin.append((fs[0] - fs[1]) / (2 * eps)) c_fin.append((gs[0] - gs[1]) / (2 * eps)) f_calc_abs[ih] = c_orig print("g fin:", numstr(g_fin), file=log) print(" ana:", numstr(trg.g), file=log) assert approx_equal(trg.g, g_fin) print("c fin:", numstr(c_fin), file=log) print(" ana:", numstr(trg.c), file=log) assert approx_equal(trg.c, c_fin) def check_f_calc_derivs(): eps = 1e-6 g_fin = flex.complex_double() c_fin = flex.vec3_double() for ih in range(f_calc.size()): c_orig = f_calc[ih] g_fin_ab = [] c_fin_ab = [] for iab in [0, 1]: fs = [] gs = [] for signed_eps in [eps, -eps]: if (iab == 0): f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag) else: f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps) trg_eps = r1.target(f_obs=f_obs, f_calc=f_calc) fs.append(trg_eps.t) gs.append(trg_eps.f_calc_gradients[ih]) g_fin_ab.append((fs[0] - fs[1]) / (2 * eps)) c_fin_ab.append((gs[0] - gs[1]) / (2 * eps)) g_fin.append(complex(*g_fin_ab)) assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real) c_fin.append( (c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag)) f_calc[ih] = c_orig for pn, f, a in zip(g_fin.part_names(), g_fin.parts(), trg.f_calc_gradients.parts()): print("g fin %s:" % pn, numstr(f), file=log) print(" ana %s:" % pn, numstr(a), file=log) assert approx_equal(trg.f_calc_gradients, g_fin) for pn, f, a in zip(["aa", "bb", "ab"], c_fin.parts(), trg.f_calc_hessians.parts()): print("c fin %s:" % pn, numstr(f), file=log) print(" ana %s:" % pn, numstr(a), file=log) assert approx_equal(trg.f_calc_hessians, c_fin) check_f_calc_abs_derivs() check_f_calc_derivs() # f_calc[0] = 0j f_calc_abs = flex.abs(f_calc) trg = r1.target(f_obs=f_obs, f_calc=f_calc) assert trg.gradients_work()[0] == 0j assert trg.hessians_work()[0] == (0, 0, 0)
def exercise(mt, n_refl, log): f_obs = mt.random_double(size=n_refl) f_calc = flex.complex_double(mt.random_double(size=f_obs.size()), mt.random_double(size=f_obs.size())) f_calc_abs = flex.abs(f_calc) trg = r1.target(f_obs=f_obs, f_calc=f_calc) def check_f_calc_abs_derivs(): eps = 1e-6 g_fin = flex.double() c_fin = flex.double() for ih in xrange(f_calc_abs.size()): fs = [] gs = [] c_orig = f_calc_abs[ih] for signed_eps in [eps, -eps]: f_calc_abs[ih] = c_orig + signed_eps trg_eps = r1.target(f_obs=f_obs, f_calc_abs=f_calc_abs) fs.append(trg_eps.t) gs.append(trg_eps.g[ih]) g_fin.append((fs[0] - fs[1]) / (2 * eps)) c_fin.append((gs[0] - gs[1]) / (2 * eps)) f_calc_abs[ih] = c_orig print >> log, "g fin:", numstr(g_fin) print >> log, " ana:", numstr(trg.g) assert approx_equal(trg.g, g_fin) print >> log, "c fin:", numstr(c_fin) print >> log, " ana:", numstr(trg.c) assert approx_equal(trg.c, c_fin) def check_f_calc_derivs(): eps = 1e-6 g_fin = flex.complex_double() c_fin = flex.vec3_double() for ih in xrange(f_calc.size()): c_orig = f_calc[ih] g_fin_ab = [] c_fin_ab = [] for iab in [0, 1]: fs = [] gs = [] for signed_eps in [eps, -eps]: if iab == 0: f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag) else: f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps) trg_eps = r1.target(f_obs=f_obs, f_calc=f_calc) fs.append(trg_eps.t) gs.append(trg_eps.f_calc_gradients[ih]) g_fin_ab.append((fs[0] - fs[1]) / (2 * eps)) c_fin_ab.append((gs[0] - gs[1]) / (2 * eps)) g_fin.append(complex(*g_fin_ab)) assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real) c_fin.append((c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag)) f_calc[ih] = c_orig for pn, f, a in zip(g_fin.part_names(), g_fin.parts(), trg.f_calc_gradients.parts()): print >> log, "g fin %s:" % pn, numstr(f) print >> log, " ana %s:" % pn, numstr(a) assert approx_equal(trg.f_calc_gradients, g_fin) for pn, f, a in zip(["aa", "bb", "ab"], c_fin.parts(), trg.f_calc_hessians.parts()): print >> log, "c fin %s:" % pn, numstr(f) print >> log, " ana %s:" % pn, numstr(a) assert approx_equal(trg.f_calc_hessians, c_fin) check_f_calc_abs_derivs() check_f_calc_derivs() # f_calc[0] = 0j f_calc_abs = flex.abs(f_calc) trg = r1.target(f_obs=f_obs, f_calc=f_calc) assert trg.gradients_work()[0] == 0j assert trg.hessians_work()[0] == (0, 0, 0)
def __get_tg(O, f_cbs, derivatives_depth=2, target=Auto, weights=Auto): if (target is Auto): target = O.params.target if (weights is Auto): weights = O.weights if (target.obs_type == "F"): obs = O.f_obs else: obs = O.i_obs if (target.type == "ls"): if (target.weighting_scheme in ["unit", "shelxl_wght_once"]): return xray.targets_least_squares( compute_scale_using_all_data=True, obs_type=target.obs_type, obs=obs.data(), weights=O.weights, r_free_flags=None, f_calc=f_cbs.data(), derivatives_depth=derivatives_depth, scale_factor=0) if (target.weighting_scheme != "shelxl_wght"): raise RuntimeError( "Unknown: target.weighting_scheme = %s" % target.weighting_scheme) assert target.obs_type == "I" if (derivatives_depth == 0): return O.calc_shelxl_wght_ls(f_cbs=f_cbs.data(), need="t") return xray.targets.shelxl_wght_ls( f_obs=O.f_obs.data(), i_obs=O.i_obs.data(), i_sig=O.i_obs.sigmas(), f_calc=f_cbs.data(), i_calc=None, wa=0.1, wb=0) elif (target.type == "cc"): return xray.targets_correlation( obs_type=target.obs_type, obs=obs.data(), weights=O.weights, r_free_flags=None, f_calc=f_cbs.data(), derivatives_depth=derivatives_depth) elif (target.type == "r1"): assert target.obs_type == "F" assert target.weighting_scheme == "unit" from cctbx.xray.targets import r1 return r1.target( f_obs=O.f_obs.data(), f_calc=f_cbs.data()) elif (target.type == "ml"): assert derivatives_depth in [0,1] if (O.epsilons is None): raise RuntimeError( "target.type=ml can only be used if bulk_solvent_correction=True") return xray.targets_maximum_likelihood_criterion( f_obs=O.f_obs.data(), r_free_flags=O.r_free_flags.data(), f_calc=f_cbs.data(), alpha=O.alpha_beta[0].data(), beta=O.alpha_beta[1].data(), scale_factor=1, epsilons=O.epsilons.data().as_double(), centric_flags=O.centric_flags.data(), compute_gradients=bool(derivatives_depth)) raise RuntimeError("Unknown target_type: %s" % target.type)
def __get_tg(O, f_cbs, derivatives_depth=2, target=Auto, weights=Auto): if (target is Auto): target = O.params.target if (weights is Auto): weights = O.weights if (target.obs_type == "F"): obs = O.f_obs else: obs = O.i_obs if (target.type == "ls"): if (target.weighting_scheme in ["unit", "shelxl_wght_once"]): return xray.targets_least_squares( compute_scale_using_all_data=True, obs_type=target.obs_type, obs=obs.data(), weights=O.weights, r_free_flags=None, f_calc=f_cbs.data(), derivatives_depth=derivatives_depth, scale_factor=0) if (target.weighting_scheme != "shelxl_wght"): raise RuntimeError( "Unknown: target.weighting_scheme = %s" % target.weighting_scheme) assert target.obs_type == "I" if (derivatives_depth == 0): return O.calc_shelxl_wght_ls(f_cbs=f_cbs.data(), need="t") return xray.targets.shelxl_wght_ls( f_obs=O.f_obs.data(), i_obs=O.i_obs.data(), i_sig=O.i_obs.sigmas(), f_calc=f_cbs.data(), i_calc=None, wa=0.1, wb=0) elif (target.type == "cc"): return xray.targets_correlation( obs_type=target.obs_type, obs=obs.data(), weights=O.weights, r_free_flags=None, f_calc=f_cbs.data(), derivatives_depth=derivatives_depth) elif (target.type == "r1"): assert target.obs_type == "F" assert target.weighting_scheme == "unit" from cctbx.xray.targets import r1 return r1.target( f_obs=O.f_obs.data(), f_calc=f_cbs.data()) elif (target.type == "ml"): assert derivatives_depth in [0,1] if (O.epsilons is None): raise RuntimeError( "target.type=ml can only be used if bulk_solvent_correction=True") return xray.mlf_target_and_gradients( f_obs=O.f_obs.data(), r_free_flags=O.r_free_flags.data(), f_calc=f_cbs.data(), alpha=O.alpha_beta[0].data(), beta=O.alpha_beta[1].data(), scale_factor=1, epsilons=O.epsilons.data().as_double(), centric_flags=O.centric_flags.data(), compute_gradients=bool(derivatives_depth)) raise RuntimeError("Unknown target_type: %s" % target.type)