pre

Bindings for core::scoring::nmr::pre namespace

class pyrosetta.rosetta.core.scoring.nmr.pre.PREData

Bases: CacheableData

assign(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData, rhs: pyrosetta.rosetta.core.scoring.nmr.pre.PREData) → pyrosetta.rosetta.core.scoring.nmr.pre.PREData

assignment operator

C++: core::scoring::nmr::pre::PREData::operator=(const class core::scoring::nmr::pre::PREData &) –> class core::scoring::nmr::pre::PREData &

clone(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: core::scoring::nmr::pre::PREData::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

compute_score_all_spinlabel(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData, pose: pyrosetta.rosetta.core.pose.Pose, individual_scores: pyrosetta.rosetta.utility.vector1_double) → float

compute the overall PRE score and individual scores for each spinlabel site

C++: core::scoring::nmr::pre::PREData::compute_score_all_spinlabel(class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &) –> double

get_number_spinlabel_sites(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData) → int

C++: core::scoring::nmr::pre::PREData::get_number_spinlabel_sites() const –> unsigned long

get_pre_multiset_vec(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_nmr_pre_PREMultiSet_t

C++: core::scoring::nmr::pre::PREData::get_pre_multiset_vec() –> class utility::vector1<class std::shared_ptr<class core::scoring::nmr::pre::PREMultiSet>, class std::allocator<class std::shared_ptr<class core::scoring::nmr::pre::PREMultiSet> > > &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

get_total_number_pre(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData) → int

C++: core::scoring::nmr::pre::PREData::get_total_number_pre() const –> unsigned long

show(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREData, TR: pyrosetta.rosetta.std.ostream) → None

C++: core::scoring::nmr::pre::PREData::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, rhs: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet

assignment operator

C++: core::scoring::nmr::pre::PREMultiSet::operator=(const class core::scoring::nmr::pre::PREMultiSet &) –> class core::scoring::nmr::pre::PREMultiSet &

compute_pre_score_from_point_vector(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, points: pyrosetta.rosetta.utility.vector1_std_pair_double_numeric_xyzVector_double_t) → float

calculates the PRE from a vector of spinlabel atom coordinates using

the modified Solomon-Bloembergen (SBMF) equation and returns the weighted PRE score according to the single PRE value weighting scheme

performs NLS fitting of the correlation times (tau_r, tau_e and tau_i)

C++: core::scoring::nmr::pre::PREMultiSet::compute_pre_score_from_point_vector(const class utility::vector1<struct std::pair<double, class numeric::xyzVector<double> >, class std::allocator<struct std::pair<double, class numeric::xyzVector<double> > > > &) –> double

compute_pre_score_from_single_point(*args, **kwargs)

Overloaded function.

1. compute_pre_score_from_single_point(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, point: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

2. compute_pre_score_from_single_point(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, point: pyrosetta.rosetta.numeric.xyzVector_double_t, opt_sl_pos: bool) -> float

calculates the PRE from a single spinlabel atom position using the simplified

Solomon-Bloembergen (SB) equation and returns the weighted PRE score according to the single PRE value weighting scheme

performs NLS fitting of the correlation times (tau_r and tau_e) by default

optionally, the spinlabel (sl) point position can be optimized too.

C++: core::scoring::nmr::pre::PREMultiSet::compute_pre_score_from_single_point(class numeric::xyzVector<double> &, bool) –> double

find_para_ion_position_and_compute_pre_score(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, pose: pyrosetta.rosetta.core.pose.Pose, spinlabel_counts_coords: pyrosetta.rosetta.utility.vector1_std_pair_double_numeric_xyzVector_double_t) → float

determines the paraion/radical atom position of the spinlabel using a gridsearch or

the dummy spinlabel rotamer ensemble and calculates the PRE score using the modified Solomon-Bloembergen (SBMF) or simplified Solomon-Bloembergen (SB) equation

C++: core::scoring::nmr::pre::PREMultiSet::find_para_ion_position_and_compute_pre_score(const class core::pose::Pose &, class utility::vector1<struct std::pair<double, class numeric::xyzVector<double> >, class std::allocator<struct std::pair<double, class numeric::xyzVector<double> > > > &) –> double

get_averaging_type(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.core.scoring.nmr.NMR_VALUE_AVERAGING_TYPE

C++: core::scoring::nmr::pre::PREMultiSet::get_averaging_type() const –> enum core::scoring::nmr::NMR_VALUE_AVERAGING_TYPE

get_gridsearch_iterator(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.core.scoring.nmr.NMRGridSearch

C++: core::scoring::nmr::pre::PREMultiSet::get_gridsearch_iterator() –> class std::shared_ptr<class core::scoring::nmr::NMRGridSearch>

get_ion_type(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.core.io.nmr.ParaIon

C++: core::scoring::nmr::pre::PREMultiSet::get_ion_type() const –> class std::shared_ptr<const class core::io::nmr::ParaIon>

get_number_experiments(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → int

C++: core::scoring::nmr::pre::PREMultiSet::get_number_experiments() const –> unsigned long

get_pre_single_weights(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::nmr::pre::PREMultiSet::get_pre_single_weights() const –> const class utility::vector1<double, class std::allocator<double> > &

get_pre_singleset_vec(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_nmr_pre_PRESingleSet_t

C++: core::scoring::nmr::pre::PREMultiSet::get_pre_singleset_vec() –> class utility::vector1<class std::shared_ptr<class core::scoring::nmr::pre::PRESingleSet>, class std::allocator<class std::shared_ptr<class core::scoring::nmr::pre::PRESingleSet> > > &

get_pre_values(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::nmr::pre::PREMultiSet::get_pre_values() const –> const class utility::vector1<double, class std::allocator<double> > &

get_protein_mass(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_protein_mass() const –> double

get_spin_coordinates(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.utility.vector1_utility_vector1_utility_vector1_numeric_xyzVector_double_std_allocator_numeric_xyzVector_double_std_allocator_utility_vector1_numeric_xyzVector_double_std_allocator_numeric_xyzVector_double_t

C++: core::scoring::nmr::pre::PREMultiSet::get_spin_coordinates() const –> const class utility::vector1<class utility::vector1<class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >, class std::allocator<class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > > >, class std::allocator<class utility::vector1<class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >, class std::allocator<class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > > > > > &

get_spinlabel(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → pyrosetta.rosetta.core.scoring.nmr.NMRSpinlabel

C++: core::scoring::nmr::pre::PREMultiSet::get_spinlabel() –> class std::shared_ptr<class core::scoring::nmr::NMRSpinlabel>

get_spinlabel_site_rsd(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → int

C++: core::scoring::nmr::pre::PREMultiSet::get_spinlabel_site_rsd() const –> unsigned long

get_tau_c(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_tau_c() const –> double

get_tau_c_max(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_tau_c_max() const –> double

get_tau_c_min(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_tau_c_min() const –> double

get_tau_r(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_tau_r() const –> double

get_tau_t(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_tau_t() const –> double

get_temperature(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_temperature() const –> double

get_total_number_pre(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → int

C++: core::scoring::nmr::pre::PREMultiSet::get_total_number_pre() const –> unsigned long

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → float

C++: core::scoring::nmr::pre::PREMultiSet::get_weight() const –> double

optimize_paraion_position(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → bool

C++: core::scoring::nmr::pre::PREMultiSet::optimize_paraion_position() const –> bool

set_atom_derivatives(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, pose: pyrosetta.rosetta.core.pose.Pose, spinlabel_counts_coords: pyrosetta.rosetta.utility.vector1_std_pair_double_numeric_xyzVector_double_t) → None

calculates and sets the xyz derivative of the PRE

single PREs must be calculated in beforehand that’s why make sure to call any of the three functions first: compute_pre_score_from_point_vector(), compute_pre_from_single_point() or find_para_ion_position_and_compute_pre_score()

C++: core::scoring::nmr::pre::PREMultiSet::set_atom_derivatives(class core::pose::Pose &, const class utility::vector1<struct std::pair<double, class numeric::xyzVector<double> >, class std::allocator<struct std::pair<double, class numeric::xyzVector<double> > > > &) –> void

set_averaging_type(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, type: str) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_averaging_type(const std::string &) –> void

set_gridsearch_iterator(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, gridsearch_ptr: pyrosetta.rosetta.core.scoring.nmr.NMRGridSearch) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_gridsearch_iterator(class std::shared_ptr<class core::scoring::nmr::NMRGridSearch>) –> void

set_protein_mass(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, mass: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_protein_mass(double) –> void

set_spinlabel(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, spinlabel_ptr: pyrosetta.rosetta.core.scoring.nmr.NMRSpinlabel) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_spinlabel(class std::shared_ptr<class core::scoring::nmr::NMRSpinlabel>) –> void

set_tau_c(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, tau_c: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_tau_c(double) –> void

set_tau_c_limits(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, tau_c_min: float, tau_c_max: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_tau_c_limits(double, double) –> void

set_tau_r(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, tau_r: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_tau_r(double) –> void

set_tau_t(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, tau_t: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_tau_t(double) –> void

set_temperature(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, temperature: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_temperature(double) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, weight: float) → None

C++: core::scoring::nmr::pre::PREMultiSet::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, TR: pyrosetta.rosetta.std.ostream) → None

C++: core::scoring::nmr::pre::PREMultiSet::show(std::ostream &) const –> void

symmetric_pre_calc(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet) → bool

C++: core::scoring::nmr::pre::PREMultiSet::symmetric_pre_calc() const –> bool

update_spin_coordinates(self: pyrosetta.rosetta.core.scoring.nmr.pre.PREMultiSet, pose: pyrosetta.rosetta.core.pose.Pose) → None

updates the spin coordinates every time the pose is changed

make sure that this function is called before you call compute_pre_score()

C++: core::scoring::nmr::pre::PREMultiSet::update_spin_coordinates(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, rhs: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle

assignment operator

C++: core::scoring::nmr::pre::PRESingle::operator=(const class core::scoring::nmr::pre::PRESingle &) –> class core::scoring::nmr::pre::PRESingle &

deserialize(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, data: pyrosetta.rosetta.std.map_std_string_utility_json_spirit_Value_impl_utility_json_spirit_Config_map_std_string_t_std_allocator_std_pair_const_std_string_utility_json_spirit_Value_impl_utility_json_spirit_Config_map_std_string_t) → None

deserialize a json_spirit object to a PRESingle object

C++: core::scoring::nmr::pre::PRESingle::deserialize(class std::map<std::string, class utility::json_spirit::Value_impl<struct utility::json_spirit::Config_map<std::string > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class utility::json_spirit::Value_impl<struct utility::json_spirit::Config_map<std::string > > > > >) –> void

get_atom_derivatives(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

C++: core::scoring::nmr::pre::PRESingle::get_atom_derivatives() const –> const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &

get_pre_calc(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → float

C++: core::scoring::nmr::pre::PRESingle::get_pre_calc() const –> double

get_pre_err(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → float

C++: core::scoring::nmr::pre::PRESingle::get_pre_err() const –> double

get_pre_exp(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → float

C++: core::scoring::nmr::pre::PRESingle::get_pre_exp() const –> double

get_pre_spin_type(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → pyrosetta.rosetta.core.scoring.nmr.PRE_SPIN_TYPE

C++: core::scoring::nmr::pre::PRESingle::get_pre_spin_type() const –> enum core::scoring::nmr::PRE_SPIN_TYPE

get_protein_spins(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::scoring::nmr::pre::PRESingle::get_protein_spins() const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → float

C++: core::scoring::nmr::pre::PRESingle::get_weight() const –> double

serialize(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle) → pyrosetta.rosetta.utility.json_spirit.Value_impl_utility_json_spirit_Config_vector_std_string_t

serialize a PRESingle object to a json_spirit object

C++: core::scoring::nmr::pre::PRESingle::serialize() const –> class utility::json_spirit::Value_impl<struct utility::json_spirit::Config_vector<std::string > >

set_atom_derivatives(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, index: int, fdx: float, fdy: float, fdz: float) → None

C++: core::scoring::nmr::pre::PRESingle::set_atom_derivatives(unsigned long, double, double, double) –> void

set_pre_calc(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, calc: float) → None

C++: core::scoring::nmr::pre::PRESingle::set_pre_calc(double) –> void

set_pre_err(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, err: float) → None

C++: core::scoring::nmr::pre::PRESingle::set_pre_err(double) –> void

set_pre_exp(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, pre: float) → None

C++: core::scoring::nmr::pre::PRESingle::set_pre_exp(double) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, weight: float) → None

C++: core::scoring::nmr::pre::PRESingle::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingle, TR: pyrosetta.rosetta.std.ostream) → None

C++: core::scoring::nmr::pre::PRESingle::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet, rhs: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet

assignment operator

C++: core::scoring::nmr::pre::PRESingleSet::operator=(const class core::scoring::nmr::pre::PRESingleSet &) –> class core::scoring::nmr::pre::PRESingleSet &

calc_gamma_I(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → float

return gyromagnetic ratio of the nuclear spin in rad/(s*T) (dimension is 10^6)

C++: core::scoring::nmr::pre::PRESingleSet::calc_gamma_I() const –> double

calc_omega_I(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → float

calculate nuclear spin frequency at given field strength in rad/s

C++: core::scoring::nmr::pre::PRESingleSet::calc_omega_I() const –> double

get_dataset_name(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → str

Getters

C++: core::scoring::nmr::pre::PRESingleSet::get_dataset_name() const –> std::string

get_field_strength(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → float

C++: core::scoring::nmr::pre::PRESingleSet::get_field_strength() const –> double

get_number_pre(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → int

C++: core::scoring::nmr::pre::PRESingleSet::get_number_pre() const –> unsigned long

get_pre_rate_type(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → pyrosetta.rosetta.core.scoring.nmr.PRE_RATE_TYPE

C++: core::scoring::nmr::pre::PRESingleSet::get_pre_rate_type() const –> enum core::scoring::nmr::PRE_RATE_TYPE

get_pre_single_vec(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → pyrosetta.rosetta.utility.vector1_core_scoring_nmr_pre_PRESingle

C++: core::scoring::nmr::pre::PRESingleSet::get_pre_single_vec() const –> const class utility::vector1<class core::scoring::nmr::pre::PRESingle, class std::allocator<class core::scoring::nmr::pre::PRESingle> > &

get_scaling_factor(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → float

C++: core::scoring::nmr::pre::PRESingleSet::get_scaling_factor() const –> double

get_single_pre_weighting_scheme(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → pyrosetta.rosetta.core.scoring.nmr.SINGLE_NMR_VALUE_WEIGHTING

C++: core::scoring::nmr::pre::PRESingleSet::get_single_pre_weighting_scheme() const –> enum core::scoring::nmr::SINGLE_NMR_VALUE_WEIGHTING

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → float

C++: core::scoring::nmr::pre::PRESingleSet::get_weight() const –> double

normalized_data(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → bool

C++: core::scoring::nmr::pre::PRESingleSet::normalized_data() const –> bool

pre_rate_type_to_string(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet) → str

C++: core::scoring::nmr::pre::PRESingleSet::pre_rate_type_to_string() const –> std::string

set_field_strength(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet, field: float) → None

C++: core::scoring::nmr::pre::PRESingleSet::set_field_strength(double) –> void

set_single_pre_weighting_scheme(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet, weighting_scheme: str) → None

C++: core::scoring::nmr::pre::PRESingleSet::set_single_pre_weighting_scheme(const std::string &) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet, weight: float) → None

C++: core::scoring::nmr::pre::PRESingleSet::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.nmr.pre.PRESingleSet, TR: pyrosetta.rosetta.std.ostream) → None

C++: core::scoring::nmr::pre::PRESingleSet::show(std::ostream &) const –> void

pyrosetta.rosetta.core.scoring.nmr.pre.pre_erf_opt_tau(par: float, m_dat: int, data: capsule, fvec: float, : int) → None

C++: core::scoring::nmr::pre::pre_erf_opt_tau(const double *, int, const void *, double *, int *) –> void

pyrosetta.rosetta.core.scoring.nmr.pre.pre_erf_opt_tau_xyz(par: float, m_dat: int, data: capsule, fvec: float, : int) → None

C++: core::scoring::nmr::pre::pre_erf_opt_tau_xyz(const double *, int, const void *, double *, int *) –> void