mmtbx.refinement package

Subpackages

Submodules

mmtbx.refinement.adp_refinement module

class mmtbx.refinement.adp_refinement.manager(fmodels, model, all_params, group_adp_selections=None, group_adp_selections_h=None, group_adp_params=None, tls_selections=None, tls_params=<libtbx.phil.scope_extract object>, individual_adp_params=<libtbx.phil.scope_extract object>, adp_restraints_params=<libtbx.phil.scope_extract object>, refine_adp_individual=None, refine_adp_group=None, refine_tls=None, tan_b_iso_max=None, restraints_manager=None, target_weights=None, macro_cycle=None, log=None, h_params=None, nproc=None)

Bases: object

class mmtbx.refinement.adp_refinement.refine_adp(model, fmodels, target_weights, individual_adp_params, adp_restraints_params, h_params, log, all_params, nproc=None)

Bases: object

minimize()
run_lbfgs()
score(rw, rf, rfrw, deltab, w, score_target, score_target_value, secondary_target=None)
select(rw, rf, rfrw, deltab, w, sel)
show(weight=None, prefix='', show_neutron=True, print_stats=True)
try_weight(weight, print_stats=False)
mmtbx.refinement.adp_refinement.show_times(out=None)
class mmtbx.refinement.adp_refinement.weight_result(r_work, r_free, delta_b, mean_b, weight, xray_target, neutron_r_work, neutron_r_free, u_star, u_iso)

Bases: object

show(out, prefix='')

mmtbx.refinement.anomalous_scatterer_groups module

mmtbx.refinement.anomalous_scatterer_groups.find_anomalous_scatterer_groups(pdb_atoms, xray_structure, group_same_element=True, out=None)

Automatic setup of anomalously scattering atoms, defined here as anything with atomic number 15 (P) or greater. Not yet accessible from phenix.refine.

mmtbx.refinement.anomalous_scatterer_groups.get_single_atom_selection_string(atom)
class mmtbx.refinement.anomalous_scatterer_groups.minimizer(fmodel, groups, call_back_after_minimizer_cycle=None, number_of_minimizer_cycles=3, lbfgs_max_iterations=20, number_of_finite_difference_tests=0)

Bases: object

compute_functional_and_gradients()
unpack()
mmtbx.refinement.anomalous_scatterer_groups.refine_anomalous_substructure(fmodel, pdb_hierarchy, wavelength=None, map_type='anom_residual', exclude_waters=False, exclude_non_water_light_elements=True, n_cycles_max=None, map_sigma_min=3.0, refine=('f_prime', 'f_double_prime'), reset_water_u_iso=True, use_all_anomalous=True, verbose=True, out=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)

Crude mimic of Phaser’s substructure completion, with two essential differences: only the existing real scatterers in the input model will be used (with the assumption that the model is already more or less complete), and the anomalous refinement will be performed in Phenix, yielding both f-prime and f-double-prime. The refined f-prime provides us with an orthogonal estimate of the number of electrons missing from an incorrectly labeled scatterer.

Parameters:

  • wavelength – X-ray wavelenth in Angstroms

  • exclude_waters – Don’t refine anomalous scattering for water oxygens

  • exclude_non_water_light_elements – Don’t refine anomalous scattering for light atoms other than water (CHNO).

  • n_cycles_max – Maximum number of refinement cycles

  • map_sigma_min – Sigma cutoff for identify anomalous scatterers

  • reset_water_u_iso – Reset B-factors for water atoms prior to f’ refinement

  • use_all_anomalous – include any scatterers which are already modeled as anomalous in the refinement

mmtbx.refinement.fit_rotamers module

mmtbx.refinement.flip_peptides module

mmtbx.refinement.geometry_minimization module

mmtbx.refinement.geometry_minimization.add_rotamer_restraints(pdb_hierarchy, restraints_manager, selection, sigma, mode=None, accept_allowed=True, mon_lib_srv=None, rotamer_manager=None)
class mmtbx.refinement.geometry_minimization.lbfgs(sites_cart, geometry_restraints_manager, geometry_restraints_flags, lbfgs_termination_params, correct_special_position_tolerance, riding_h_manager=None, sites_cart_selection=None, lbfgs_exception_handling_params=None, rmsd_bonds_termination_cutoff=0, rmsd_angles_termination_cutoff=0, states_collector=None, site_labels=None)

Bases: lbfgs

callback_after_step(minimizer)
mmtbx.refinement.geometry_minimization.minimize_wrapper_for_ramachandran(model, original_pdb_h, excl_string_selection, processed_pdb_file=None, log=None, reference_rotamers=True, number_of_cycles=1, run_first_minimization_without_reference=False, oldfield_weight_scale=3, oldfield_plot_cutoff=0.03, nonbonded_weight=500, reference_sigma=0.7)

Wrapper around geometry minimization specifically tuned for eliminating Ramachandran outliers. probably not working anymore… no processed_pdb_file available. WARNING: no setting sites_cart at the end…

class mmtbx.refinement.geometry_minimization.run2(restraints_manager, pdb_hierarchy, correct_special_position_tolerance, riding_h_manager=None, ncs_restraints_group_list=[], max_number_of_iterations=500, number_of_macro_cycles=5, selection=None, bond=False, nonbonded=False, angle=False, dihedral=False, chirality=False, planarity=False, parallelity=False, rmsd_bonds_termination_cutoff=0, rmsd_angles_termination_cutoff=0, alternate_nonbonded_off_on=False, cdl=False, rdl=False, correct_hydrogens=False, fix_rotamer_outliers=True, allow_allowed_rotamers=True, states_collector=None, log=None, mon_lib_srv=None, ias_selection=None)

Bases: object

show()
update_cdl_restraints(macro_cycle=None)
updaterdl(prefix)

mmtbx.refinement.group module

mmtbx.refinement.group.apply_transformation(xray_structure, par, selections, sc_start, refine_adp, refine_occ)
class mmtbx.refinement.group.group_minimizer(fmodel, sc_start, selections, par_initial, refine_adp, refine_occ, max_number_of_iterations, run_finite_differences_test=False, restraints_weight=None, restraints_manager=None)

Bases: object

apply_shifts(par)
compute_functional_and_gradients()
finite_difference_test()
get_restraints_tg()
get_tg(compute_gradients)
pack(par)
unpack_x()
class mmtbx.refinement.group.manager(fmodel, selections=None, max_number_of_iterations=50, number_of_macro_cycles=5, use_restraints=False, restraints_weight=None, convergence_test=True, convergence_delta=1e-05, run_finite_differences_test=False, refine_adp=False, refine_occ=False, log=None, occupancy_max=None, occupancy_min=None)

Bases: object

show(rw, rf, tw, mc, it, refine_adp, refine_occ, weight, out)
mmtbx.refinement.group.show_times(out=None)
class mmtbx.refinement.group.sphere_similarity_restraints(xray_structure, selection, refine_adp, refine_occ, sphere_radius=5.0)

Bases: object

target_and_gradients(xray_structure, to_compute_weight=False)
class mmtbx.refinement.group.target_and_grads(target_functor, selections, refine_adp, refine_occ, compute_gradients=True, rtg=None, weight=None)

Bases: object

gradients_wrt_par()
target()

mmtbx.refinement.inspect_tardy_trajectory module

mmtbx.refinement.inspect_tardy_trajectory.run(args)

mmtbx.refinement.minimization module

class mmtbx.refinement.minimization.lbfgs(fmodels, restraints_manager=None, model=None, is_neutron_scat_table=None, target_weights=None, refine_xyz=False, refine_adp=False, lbfgs_termination_params=None, use_fortran=False, verbose=0, correct_special_position_tolerance=1.0, iso_restraints=None, h_params=None, qblib_params=None, macro_cycle=None, u_min=-0.06332573977646111, u_max=12.665021303812669, collect_monitor=True, log=None)

Bases: object

apply_shifts()
callback_after_step(minimizer)
compute_functional_and_gradients()
compute_target(compute_gradients, u_iso_refinable_params)
class mmtbx.refinement.minimization.monitor(weights, fmodels, model, iso_restraints, refine_xyz=False, refine_adp=False, refine_occ=False)

Bases: object

collect(iter=None, nfun=None)
neutron_line(i_seq)
show(message='', log=None)
xray_line(i_seq)
class mmtbx.refinement.minimization.run_constrained(model, fmodel, target_weight, log, params, prefix, refine_sites=False, refine_u_iso=False, refine_transformations=False)

Bases: object

mmtbx.refinement.minimization_ncs_constraints module

mmtbx.refinement.minimization_ncs_constraints.grads_asu_to_one_ncs(ncs_restraints_group_list, extended_ncs_selection, grad, refine_sites)

Apply NCS constraints to reduce the gradients corresponding to whole ASU, to gradients corresponding to one NCS copy.

Parameters:

  • ncs_restraints_group_list – list of ncs_restraint_group objects

  • grad – gradient of the complete asu

  • refine_sites – (bool) Flag indicating sites refinement

  • extended_ncs_selection (flex.siz_t) – selection of all ncs groups master ncs selection and non ncs related portions that are being refined (exclude NCS copies)

mmtbx.refinement.minimization_ncs_constraints.grads_one_ncs_to_asu(ncs_restraints_group_list, total_asu_length, extended_ncs_selection, master_grad)

Expand average gradient of a single NCS to all ASU (only for u_iso refinement)

Parameters:

  • ncs_restraints_group_list – list of ncs_restraint_group objects

  • total_asu_length (int) – length of the complete ASU

  • extended_ncs_selection (flex.size_t) – selection of all ncs groups master ncs selection and non ncs related portions that are being refined (exclude NCS copies)

  • master_grad – gradient of a single ncs copy (the master copy)

class mmtbx.refinement.minimization_ncs_constraints.lbfgs(ncs_restraints_group_list, target_and_grads_object, xray_structure, refine_selection=None, finite_grad_differences_test=False, finite_grad_difference_val=0, max_iterations=35, refine_sites=False, refine_u_iso=False, refine_transformations=False)

Bases: object

compute_functional_and_gradients(compute_gradients=True)
finite_difference_test(g)

Compare analytical and finite differences gradients.

finite_grad_difference_val = abs(analytical - finite differences)

refinable_params_one_ncs_to_asu(x=None)

Expand refinabale parameters corresponding to one NCS copy to parameters corresponding to whole ASU.

update_xray_structure(x=None)

Update xray_structure with refined parameters, then update fmodel object with updated xray_structure.

mmtbx.refinement.minimization_ncs_constraints.restraints_target_and_grads(ncs_restraints_group_list, restraints_manager, xray_structure, grad, x, refine_sites=False, refine_u_iso=False, refine_transformations=False, iso_restraints=None, use_hd=None)
Parameters:

  • ncs_restraints_group_list – NCS operator list

  • restraints_manager – (object)

  • xray_structure – (object)

  • grad – gradient without restraints

  • x – refined parameter

  • refine_sites – (bool) indicate refinement type

  • refine_u_iso – (bool) indicate refinement type

  • refine_transformations – (bool) indicate refinement type

  • iso_restraints – (object) iso restraints parameters

  • use_hd – (bool) Use hydrogen

Returns:

(float) restraints target function value ef_grad: (flex.double or flex.vec3_double) restraints gradient

Return type:

ef_target

class mmtbx.refinement.minimization_ncs_constraints.target_function_and_grads_geometry_minimization(xray_structure, ncs_restraints_group_list, refine_selection=None, use_ncs_constraints=True, restraints_manager=None, refine_sites=False, refine_transformations=False)

Bases: object

Target and gradients evaluator for geometry minimization (no data)

target_and_gradients(compute_gradients, xray_structure, x)
class mmtbx.refinement.minimization_ncs_constraints.target_function_and_grads_real_space(map_data, xray_structure, ncs_restraints_group_list, real_space_gradients_delta, refine_selection=None, use_ncs_constraints=True, restraints_manager=None, data_weight=None, refine_sites=False)

Bases: object

Real-space target and gradients evaluator

data_target_and_grads(compute_gradients, x)
Parameters:

  • compute_gradients – (bool) when True compute gradients

  • x – refined parameters

target_and_gradients(compute_gradients, xray_structure, x)
Parameters:

  • compute_gradients – (bool) when True compute gradients

  • xray_structure – xray_structure object

  • x – refined parameters

class mmtbx.refinement.minimization_ncs_constraints.target_function_and_grads_reciprocal_space(fmodel, ncs_restraints_group_list, refine_selection=None, use_ncs_constraints=True, restraints_manager=None, data_weight=None, refine_sites=False, refine_u_iso=False, refine_transformations=False, iso_restraints=None, use_hd=False)

Bases: object

Reciprocal-space target and gradients evaluator

Parameters:

refine_selection (flex.size_t) – of all ncs related copies and non ncs related parts to be refined

data_target_and_grads(compute_gradients, sites_cart, x)
finalize()
target_and_gradients(compute_gradients, xray_structure, x)

mmtbx.refinement.occupancies module

mmtbx.refinement.occupancies.add_occupancy_selection(result, size, selection, hd_special=None)
mmtbx.refinement.occupancies.assemble_constraint_groups_3d(xray_structure, pdb_atoms, constraint_groups, interaction_distance_cutoff=4.0, verbose=False, log=None)

Re-sorts occupancy constraint groups so that conformers whose motion is correlated (i.e. they interact in 3D, without necessarily being part of the same fragment/molecule/ASU) are grouped together. As input, it expects the constraint groups output by mmtbx.utils.occupancy_selections(), which will already have connectivity taken into account. This function will exit with an error if the occupancies for the new groups are not consistent.

mmtbx.refinement.occupancies.extract_partial_occupancy_selections(hierarchy)
mmtbx.refinement.occupancies.list_3d_as_bool_selection(list_3d, size)
class mmtbx.refinement.occupancies.manager(fmodels, model, max_number_of_iterations=25, number_of_macro_cycles=3, occupancy_max=None, occupancy_min=None, log=None, exclude_hd=False)

Bases: object

show(fmodels, message, log)
show_helper(fmodel, log)
class mmtbx.refinement.occupancies.minimizer(fmodels, constrained_groups_selections, selections, par_initial, max_number_of_iterations)

Bases: object

compute_functional_and_gradients()
pack(par)
unpack_x()
mmtbx.refinement.occupancies.occupancy_regroupping(pdb_hierarchy, cgs)
mmtbx.refinement.occupancies.occupancy_selections(model, add_water=False, other_individual_selection_strings=None, other_constrained_groups=None, remove_selection=None, as_flex_arrays=True, constrain_correlated_3d_groups=False, log=None)
mmtbx.refinement.occupancies.pack_gradients(x, table)
mmtbx.refinement.occupancies.pack_unpack(x, table)
mmtbx.refinement.occupancies.set_refinable_parameters(xray_structure, parameters, selections, enforce_positivity=False)

mmtbx.refinement.orca module

mmtbx.refinement.orca.average_sites_cart(related_x_i_seqs, x_sites_cart)
class mmtbx.refinement.orca.expand(labels, sites_cart, masses, geo_manager)

Bases: object

rmsd_calculation(sites_cart_1, sites_cart_2)
rmsd_calculator(tardy_tree_rmsd_calculator)
mmtbx.refinement.orca.expand_angle_proxies(angle_proxies, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_bond_params_table(bond_params_table, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_dihedral_or_chirality_proxies(proxies, proxy_type, proxy_array_type, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_model_or_conformer_indices(indices, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_nonbonded_types(nonbonded_types, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_pair_sym_table(pair_sym_table, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_planarity_proxies(planarity_proxies, x_n_seq, related_x_i_seqs)
mmtbx.refinement.orca.expand_site_symmetry_table(site_symmetry_table, x_n_seq, related_x_i_seqs)

mmtbx.refinement.print_statistics module

class mmtbx.refinement.print_statistics.annealing_callback(model, monitor)

Bases: object

class mmtbx.refinement.print_statistics.coordinate_shifts(hierarchy_start, hierarchy_end)

Bases: object

get_shifts()
min_max_mean()
save_pdb_file(file_name)
mmtbx.refinement.print_statistics.macro_cycle_header(macro_cycle, number_of_macro_cycles, out=None)
mmtbx.refinement.print_statistics.make_header(line, out=None)
mmtbx.refinement.print_statistics.make_sub_header(text, out=None)
class mmtbx.refinement.print_statistics.refinement_monitor(params, out=None, neutron_refinement=None, call_back_handler=None, is_neutron_monitor=False)

Bases: object

call_back(model, fmodel, method='monitor_collect')
collect(model, fmodel, step, wilson_b=None, rigid_body_shift_accumulator=None)
dump_statistics(file_name)
format_stats_for_phenix_gui()
show(out=None, remark='')
show_current_r_factors_summary(out, prefix='')
mmtbx.refinement.print_statistics.show_process_info(out)
mmtbx.refinement.print_statistics.show_rigid_body_rotations_and_translations(out, prefix, frame, euler_angle_convention, rotations, translations)
mmtbx.refinement.print_statistics.show_times(out=None)
class mmtbx.refinement.print_statistics.stats_table(**kwds)

Bases: slots_getstate_setstate

as_ave
bs_ave
neutron_flag
r_frees
r_works
steps
class mmtbx.refinement.print_statistics.trajectory_output(file_base='refine', filled_maps=True, log=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, verbose=True)

Bases: object

Callback object for saving the intermediate results of refinement as a stack of PDB and MTZ files. Equivalent to the interactivity with Coot in the Phenix GUI, but intended for command-line use and demonstrative purposes.

mmtbx.refinement.refinement_flags module

class mmtbx.refinement.refinement_flags.manager(individual_sites=False, torsion_angles=False, rigid_body=False, individual_adp=False, group_adp=False, tls=False, occupancies=False, group_anomalous=False, sites_individual=None, sites_torsion_angles=None, sites_rigid_body=None, adp_individual_iso=None, adp_individual_aniso=None, adp_group=None, group_h=None, adp_tls=None, s_occupancies=None)

Bases: object

add(next_to_i_seqs, sites_individual=False, sites_torsion_angles=False, sites_rigid_body=False, adp_individual_iso=False, adp_individual_aniso=False, adp_group=False, group_h=False, adp_tls=False, s_occupancies=False)
ca(x)
check_all()
count_occupancies(x)
deep_copy()
inflate(sites_individual=None, sites_torsion_angles=None, sites_rigid_body=None, adp_individual_iso=None, adp_individual_aniso=None, adp_group=None, group_h=None, adp_tls=None, s_occupancies=None, occupancies_group=None, size_all=None)
is_bool(x)
is_size_t(x)
select(selection)
select_detached(selection)
show(log=None)
szs(x)

mmtbx.refinement.rigid_body module

mmtbx.refinement.rigid_body.apply_transformation(xray_structure, rotation_matrices, translation_vectors, selections)
mmtbx.refinement.rigid_body.apply_transformation_(xray_structure, sites_cart, sites_frac, rotation_matrices, translation_vectors, selections, atomic_weights)
class mmtbx.refinement.rigid_body.manager(fmodel, selections=None, params=None, r_initial=None, t_initial=None, bss=None, log=None, monitors=None)

Bases: object

evaluate_after_end(fmodel, save_r_work, save_r_free, save_xray_structure, log)
rotation()
show(fmodel, r_mat, t_vec, header='', out=None)
translation()
class mmtbx.refinement.rigid_body.rigid_body_minimizer(fmodel, selections, r_initial, t_initial, refine_r, refine_t, max_iterations, euler_angle_convention, lbfgs_maxfev)

Bases: object

compute_functional_and_gradients(suppress_gradients=False)
pack(r, t)
unpack_x()
class mmtbx.refinement.rigid_body.rigid_body_shift_accumulator(euler_angle_convention)

Bases: object

add(rotations, translations)
show(out=None)
mmtbx.refinement.rigid_body.rigid_groups_from_pdb_chains(pdb_hierarchy, min_chain_size=2, xray_structure=None, check_for_atoms_on_special_positions=None, group_all_by_chain=False, log=None)
mmtbx.refinement.rigid_body.split_resolution_range(d_spacings, n_bodies, target, target_auto_switch_resolution, n_ref_first, multi_body_factor_n_ref_first, d_low, d_high, number_of_zones, zone_exponent, log=None)
class mmtbx.refinement.rigid_body.target_and_grads(centers_of_mass, sites_cart, target_functor, rot_objs, selections, suppress_gradients)

Bases: object

gradients_wrt_r()
gradients_wrt_t()
target()

mmtbx.refinement.select_best_starting_model module

This module provides a way to identify a suitably isomorphous initial model for directly refining against experimental data. This is commonly done when solving a series of ligand-bound structures, partly to save time, and partly to avoid changing the frame of reference when running molecular replacement.

class mmtbx.refinement.select_best_starting_model.evaluate_model(xray_structure, pdb_hierarchy, f_obs, r_free_flags, rigid_body_refine=False, optimize_b_factors=False, skip_twin_detection=False, scattering_table='n_gaussian')

Bases: slots_getstate_setstate

Create an fmodel object (including bulk solvent correction) and calculate R-factors, with or without optional rigid-body refinement.

r_free
r_free_start
r_work
r_work_start
show(out=<colorama.ansitowin32.StreamWrapper object>, prefix='')
xray_structure
class mmtbx.refinement.select_best_starting_model.select_model(model_names, model_data, f_obs, r_free_flags, params=None, skip_twin_detection=False, nproc=1, log=<colorama.ansitowin32.StreamWrapper object>)

Bases: object

evaluate_model(args)
get_best_model(update_structure=True)
r_free()
r_work()
save_best_model(file_name='best_model.pdb')
save_updated_data(file_name='best_model_data.mtz')
show(out=<colorama.ansitowin32.StreamWrapper object>, verbose=False)
space_group_info()
success()
mmtbx.refinement.select_best_starting_model.strip_model(pdb_hierarchy=None, xray_structure=None, file_name=None, params=None, remove_waters=True, remove_hydrogens=True, remove_alt_confs=True, convert_semet_to_met=True, convert_to_isotropic=True, reset_occupancies=True, remove_ligands=False, reset_hetatm_flag=False, preserve_remarks=False, preserve_symmetry=True, add_remarks=None, output_file=None, log=None)

Utility for removing extraneous records from a model intended for use in molecular replacement, etc., including waters, alternate conformations, and other features specific to a particular dataset.

mmtbx.refinement.select_best_starting_model.ucf(unit_cell)

mmtbx.refinement.tardy module

mmtbx.refinement.tardy.action(tardy_model, params, rmsd_calculator, callback, log, fmodel=None, format_for_phenix_refine=False, refinement_callback=None)
class mmtbx.refinement.tardy.potential_object(xray_weight_factor, prolsq_repulsion_function_changes, fmodels, model, target_weights, reduced_geo_manager)

Bases: object

crystal_symmetry()
d_e_pot_d_sites(sites_moved)
e_pot(sites_moved)
mmtbx.refinement.tardy.run(fmodels, model, target_weights, params, log, format_for_phenix_refine=False, monitor=None, call_back_after_step=True)

mmtbx.refinement.targets module

mmtbx.refinement.targets.ls_ff_weights(f_obs, atom, B)
mmtbx.refinement.targets.ls_sigma_weights(f_obs)
class mmtbx.refinement.targets.phaser_sad_target_functor(f_obs, r_free_flags, xray_structure, f_calc, target_memory)

Bases: object

prepare_for_minimization()
target_memory()
class mmtbx.refinement.targets.target_attributes(family, specialization=None)

Bases: object

requires_experimental_phases()
validate()
class mmtbx.refinement.targets.target_functor(manager, alpha_beta=None)

Bases: object

prepare_for_minimization()
target_function_is_invariant_under_allowed_origin_shifts()
class mmtbx.refinement.targets.target_result(manager, core_result)

Bases: target_result_mixin

d_target_d_f_calc_work()
d_target_d_f_model_work()
target_per_reflection()
target_test()
target_work()
class mmtbx.refinement.targets.target_result_mixin

Bases: object

d_target_d_site_cart()
gradients_wrt_atomic_parameters(selection=None, site=False, u_iso=False, u_aniso=False, occupancy=False, tan_b_iso_max=None, u_iso_refinable_params=None)

mmtbx.refinement.weights_params module

mmtbx.refinement.wx_tardy_pdb module

Module contents

class mmtbx.refinement.monitors(params, model, fmodels, log=None, neutron_refinement=None, call_back_handler=None)

Bases: object

collect(step, fmodels=None, model=None, rigid_body_shift_accumulator=None)