rdc¶

Bindings for core::scoring::nmr::rdc namespace

class pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData¶

Bases: CacheableData

assign(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData, rhs: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData) → pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData¶

assignment operator

C++: core::scoring::nmr::rdc::RDCData::operator=(const class core::scoring::nmr::rdc::RDCData &) –> class core::scoring::nmr::rdc::RDCData &

clone(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::nmr::rdc::RDCData::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get_number_alignment_media(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData) → int¶: C++: core::scoring::nmr::rdc::RDCData::get_number_alignment_media() const –> unsigned long

get_rdc_multiset_vec(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_nmr_rdc_RDCMultiSet_t¶: C++: core::scoring::nmr::rdc::RDCData::get_rdc_multiset_vec() –> class utility::vector1<class std::shared_ptr<class core::scoring::nmr::rdc::RDCMultiSet>, class std::allocator<class std::shared_ptr<class core::scoring::nmr::rdc::RDCMultiSet> > > &

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_rdc(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData) → int¶: C++: core::scoring::nmr::rdc::RDCData::get_total_number_rdc() const –> unsigned long

show(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCData, TR: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::nmr::rdc::RDCData::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet¶

Bases: pybind11_object

class COMPUTATION_TYPE¶

Bases: pybind11_object

type of tensor and score calculation: SVD = singular value decomposition (coupled with grid search) NLS = non-linear least squares fitting NLSDA = non-linear least squares fitting with known alignment magnitude NLSR = non-linear least squares fitting with known rhombicity NLSDAR = non-linear least squares fitting with known alignment magnitude and rhombicity

Members:

SVD

NLS

NLSDA

NLSR

NLSDAR

NLS = <COMPUTATION_TYPE.NLS: 2>¶

NLSDA = <COMPUTATION_TYPE.NLSDA: 3>¶

NLSDAR = <COMPUTATION_TYPE.NLSDAR: 5>¶

NLSR = <COMPUTATION_TYPE.NLSR: 4>¶

SVD = <COMPUTATION_TYPE.SVD: 1>¶

property name¶

property value¶

NLS = <COMPUTATION_TYPE.NLS: 2>¶

NLSDA = <COMPUTATION_TYPE.NLSDA: 3>¶

NLSDAR = <COMPUTATION_TYPE.NLSDAR: 5>¶

NLSR = <COMPUTATION_TYPE.NLSR: 4>¶

SVD = <COMPUTATION_TYPE.SVD: 1>¶

assign(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, rhs: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet¶

assignment operator

C++: core::scoring::nmr::rdc::RDCMultiSet::operator=(const class core::scoring::nmr::rdc::RDCMultiSet &) –> class core::scoring::nmr::rdc::RDCMultiSet &

compute_rdc_values_and_score_from_tensor(*args, **kwargs)¶

Overloaded function.

compute_rdc_values_and_score_from_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, tensor: core::scoring::nmr::rdc::RDCTensor) -> float

calculate RDC values from a given tensor, set values in the RDCSingle vector: and return the RDC score

C++: core::scoring::nmr::rdc::RDCMultiSet::compute_rdc_values_and_score_from_tensor(const class core::scoring::nmr::rdc::RDCTensor &) –> double

compute_rdc_values_and_score_from_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) -> float

calculate RDC values and the RDC score from the dataset’s current tensor

C++: core::scoring::nmr::rdc::RDCMultiSet::compute_rdc_values_and_score_from_tensor() –> double

correct_sign(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → bool¶: C++: core::scoring::nmr::rdc::RDCMultiSet::correct_sign() const –> bool

fix_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::fix_tensor() –> void

get_alignment_medium_label(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → str¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_alignment_medium_label() const –> std::string

get_averaging_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.core.scoring.nmr.NMR_VALUE_AVERAGING_TYPE¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_averaging_type() const –> enum core::scoring::nmr::NMR_VALUE_AVERAGING_TYPE

get_computation_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet.COMPUTATION_TYPE¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_computation_type() const –> enum core::scoring::nmr::rdc::RDCMultiSet::COMPUTATION_TYPE

get_matrix_A(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_matrix_A() const –> const class ObjexxFCL::FArray2D<double> &

get_normalization_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.core.scoring.nmr.RDC_NORM_TYPE¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_normalization_type() const –> enum core::scoring::nmr::RDC_NORM_TYPE

get_number_experiments(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → int¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_number_experiments() const –> unsigned long

get_rdc_single_weights(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_rdc_single_weights() const –> const class ObjexxFCL::FArray1D<double> &

get_rdc_singleset_vec(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_nmr_rdc_RDCSingleSet_t¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_rdc_singleset_vec() –> class utility::vector1<class std::shared_ptr<class core::scoring::nmr::rdc::RDCSingleSet>, class std::allocator<class std::shared_ptr<class core::scoring::nmr::rdc::RDCSingleSet> > > &

get_rdc_values(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_rdc_values() const –> const class ObjexxFCL::FArray1D<double> &

get_spin_coordinates(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_numeric_xyzVector_double_numeric_xyzVector_double_std_allocator_std_pair_numeric_xyzVector_double_numeric_xyzVector_double_t¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_spin_coordinates() const –> const class utility::vector1<class utility::vector1<struct std::pair<class numeric::xyzVector<double>, class numeric::xyzVector<double> >, class std::allocator<struct std::pair<class numeric::xyzVector<double>, class numeric::xyzVector<double> > > >, class std::allocator<class utility::vector1<struct std::pair<class numeric::xyzVector<double>, class numeric::xyzVector<double> >, class std::allocator<struct std::pair<class numeric::xyzVector<double>, class numeric::xyzVector<double> > > > > > &

get_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → core::scoring::nmr::rdc::RDCTensor¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_tensor() –> class std::shared_ptr<class core::scoring::nmr::rdc::RDCTensor>

get_tensor_const(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → core::scoring::nmr::rdc::RDCTensor¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_tensor_const() const –> class std::shared_ptr<const class core::scoring::nmr::rdc::RDCTensor>

get_total_number_rdc(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → int¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_total_number_rdc() const –> unsigned long

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → float¶: C++: core::scoring::nmr::rdc::RDCMultiSet::get_weight() const –> double

set_atom_derivatives(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

sets the xyz derivative of the RDC: RDCTensor must be determined before first call solve_tensor_and_compute_score_by_svd() or solve_tensor_and_compute_score_by_nls() before setting derivatives

C++: core::scoring::nmr::rdc::RDCMultiSet::set_atom_derivatives(const class core::pose::Pose &) –> void

set_averaging_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, type: str) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::set_averaging_type(const std::string &) –> void

set_computation_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, type: str) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::set_computation_type(const std::string &) –> void

set_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, tensor: core::scoring::nmr::rdc::RDCTensor) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::set_tensor(const class std::shared_ptr<class core::scoring::nmr::rdc::RDCTensor> &) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, weight: float) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, TR: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::show(std::ostream &) const –> void

solve_tensor_and_compute_score_by_nls(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → float¶

solves the RDC tensor using NLS and returns the weighted RDC score: according to the single RDC weighting scheme and the weights of the individual experiments

C++: core::scoring::nmr::rdc::RDCMultiSet::solve_tensor_and_compute_score_by_nls() –> double

solve_tensor_and_compute_score_by_svd(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → float¶

solves the RDC tensor using SVD and returns the weighted RDC score: according to the single RDC weighting scheme and the weights of the individual experiments

C++: core::scoring::nmr::rdc::RDCMultiSet::solve_tensor_and_compute_score_by_svd() –> double

symmetric_rdc_calc(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → bool¶: C++: core::scoring::nmr::rdc::RDCMultiSet::symmetric_rdc_calc() const –> bool

tensor_fixed(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → bool¶: C++: core::scoring::nmr::rdc::RDCMultiSet::tensor_fixed() const –> bool

unfix_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → None¶: C++: core::scoring::nmr::rdc::RDCMultiSet::unfix_tensor() –> void

update_matrix_A(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → None¶

builds matrix_A from the spin coordinates and hands it over to the SVD solver

C++: core::scoring::nmr::rdc::RDCMultiSet::update_matrix_A() –> void

update_single_rdc_weighting(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet) → None¶

updates the array holding the single RDC weights that are used during score calculation: needs to be called e.g. when the weighting scheme of one of the RDCSingleSets was changed

C++: core::scoring::nmr::rdc::RDCMultiSet::update_single_rdc_weighting() –> void

update_spin_coordinates(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCMultiSet, 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 update_matrix_A() is called

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

class pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, rhs: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle¶

assignment operator

C++: core::scoring::nmr::rdc::RDCSingle::operator=(const class core::scoring::nmr::rdc::RDCSingle &) –> class core::scoring::nmr::rdc::RDCSingle &

deserialize(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, 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 RDCSingle object

C++: core::scoring::nmr::rdc::RDCSingle::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.rdc.RDCSingle) → pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_numeric_xyzVector_double_t¶: C++: core::scoring::nmr::rdc::RDCSingle::get_atom_derivatives() const –> const class utility::vector1<struct std::pair<class numeric::xyzVector<double>, class numeric::xyzVector<double> >, class std::allocator<struct std::pair<class numeric::xyzVector<double>, class numeric::xyzVector<double> > > > &

get_rdc_calc(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → float¶: C++: core::scoring::nmr::rdc::RDCSingle::get_rdc_calc() const –> double

get_rdc_err(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → float¶: C++: core::scoring::nmr::rdc::RDCSingle::get_rdc_err() const –> double

get_rdc_exp(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → float¶: C++: core::scoring::nmr::rdc::RDCSingle::get_rdc_exp() const –> double

get_rdc_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE¶: C++: core::scoring::nmr::rdc::RDCSingle::get_rdc_type() const –> enum core::scoring::nmr::RDC_TYPE

get_spinsAB(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → pyrosetta.rosetta.utility.vector1_std_pair_core_id_AtomID_core_id_AtomID_t¶: C++: core::scoring::nmr::rdc::RDCSingle::get_spinsAB() const –> const class utility::vector1<struct std::pair<class core::id::AtomID, class core::id::AtomID>, class std::allocator<struct std::pair<class core::id::AtomID, class core::id::AtomID> > > &

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → float¶: C++: core::scoring::nmr::rdc::RDCSingle::get_weight() const –> double

serialize(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle) → pyrosetta.rosetta.utility.json_spirit.Value_impl_utility_json_spirit_Config_vector_std_string_t¶

serialize a RDCSingle object to a json_spirit object

C++: core::scoring::nmr::rdc::RDCSingle::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.rdc.RDCSingle, idx: int, fdx: float, fdy: float, fdz: float) → None¶: C++: core::scoring::nmr::rdc::RDCSingle::set_atom_derivatives(unsigned long, double, double, double) –> void

set_rdc_calc(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, calc: float) → None¶: C++: core::scoring::nmr::rdc::RDCSingle::set_rdc_calc(double) –> void

set_rdc_err(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, err: float) → None¶: C++: core::scoring::nmr::rdc::RDCSingle::set_rdc_err(double) –> void

set_rdc_exp(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, rdc: float) → None¶: C++: core::scoring::nmr::rdc::RDCSingle::set_rdc_exp(double) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, weight: float) → None¶: C++: core::scoring::nmr::rdc::RDCSingle::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingle, TR: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::nmr::rdc::RDCSingle::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet, rhs: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet¶

assignment operator

C++: core::scoring::nmr::rdc::RDCSingleSet::operator=(const class core::scoring::nmr::rdc::RDCSingleSet &) –> class core::scoring::nmr::rdc::RDCSingleSet &

get_dataset_name(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → str¶: C++: core::scoring::nmr::rdc::RDCSingleSet::get_dataset_name() const –> std::string

get_number_rdc(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → int¶: C++: core::scoring::nmr::rdc::RDCSingleSet::get_number_rdc() const –> unsigned long

get_rdc_type(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE¶: C++: core::scoring::nmr::rdc::RDCSingleSet::get_rdc_type() const –> enum core::scoring::nmr::RDC_TYPE

get_single_rdc_vec(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → pyrosetta.rosetta.utility.vector1_core_scoring_nmr_rdc_RDCSingle¶: C++: core::scoring::nmr::rdc::RDCSingleSet::get_single_rdc_vec() const –> const class utility::vector1<class core::scoring::nmr::rdc::RDCSingle, class std::allocator<class core::scoring::nmr::rdc::RDCSingle> > &

get_single_rdc_weighting_scheme(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → pyrosetta.rosetta.core.scoring.nmr.SINGLE_NMR_VALUE_WEIGHTING¶: C++: core::scoring::nmr::rdc::RDCSingleSet::get_single_rdc_weighting_scheme() const –> enum core::scoring::nmr::SINGLE_NMR_VALUE_WEIGHTING

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet) → float¶: C++: core::scoring::nmr::rdc::RDCSingleSet::get_weight() const –> double

set_single_rdc_weighting_scheme(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet, weighting_scheme: str) → None¶: C++: core::scoring::nmr::rdc::RDCSingleSet::set_single_rdc_weighting_scheme(const std::string &) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet, weight: float) → None¶: C++: core::scoring::nmr::rdc::RDCSingleSet::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCSingleSet, TR: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::nmr::rdc::RDCSingleSet::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor¶

Bases: NMRTensor

assign(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, rhs: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor¶

assignment operator

C++: core::scoring::nmr::rdc::RDCTensor::operator=(const class core::scoring::nmr::rdc::RDCTensor &) –> class core::scoring::nmr::rdc::RDCTensor &

deserialize(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, 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 an RDCTensor

C++: core::scoring::nmr::rdc::RDCTensor::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

diagonalize_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → None¶

brings alignment tensor in principal axis frame by diagonalization: make sure to call either set_tensor_in_arbitrary_frame() and set_Dmax() or set_tensor_in_pas() first

C++: core::scoring::nmr::rdc::RDCTensor::diagonalize_tensor() –> void

get_Da(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → float¶: C++: core::scoring::nmr::rdc::RDCTensor::get_Da() const –> double

get_Dmax(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → float¶: C++: core::scoring::nmr::rdc::RDCTensor::get_Dmax() const –> double

get_Eig_xx(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_Eig_xx() const –> double

get_Eig_yy(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_Eig_yy() const –> double

get_Eig_zz(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_Eig_zz() const –> double

get_R(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → float¶: C++: core::scoring::nmr::rdc::RDCTensor::get_R() const –> double

get_T_xx(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_T_xx() const –> double

get_T_xy(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_T_xy() const –> double

get_T_xz(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_T_xz() const –> double

get_T_yy(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_T_yy() const –> double

get_T_yz(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_T_yz() const –> double

get_alpha(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_alpha() const –> double

get_ax(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_ax() const –> double

get_beta(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_beta() const –> double

get_euler_convention(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → pyrosetta.rosetta.core.scoring.nmr.EULER_CONVENTION¶: C++: core::scoring::nmr::NMRTensor::get_euler_convention() const –> enum core::scoring::nmr::EULER_CONVENTION

get_gamma(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_gamma() const –> double

get_rh(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float¶: C++: core::scoring::nmr::NMRTensor::get_rh() const –> double

is_rdc_tensor_in_arbitrary_frame(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → bool¶: C++: core::scoring::nmr::rdc::RDCTensor::is_rdc_tensor_in_arbitrary_frame() const –> bool

is_rdc_tensor_in_pas(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → bool¶: C++: core::scoring::nmr::rdc::RDCTensor::is_rdc_tensor_in_pas() const –> bool

is_tensor_diagonalized(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → bool¶: C++: core::scoring::nmr::rdc::RDCTensor::is_tensor_diagonalized() const –> bool

is_tensor_reconfigured(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → bool¶: C++: core::scoring::nmr::rdc::RDCTensor::is_tensor_reconfigured() const –> bool

reorder_tensor(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → None¶

brings alignment tensor principal values in correct order: and reconfigure tensor into unique tensor representation make sure to call set_tensor_in_pas() or diagonalize_tensor() first

C++: core::scoring::nmr::rdc::RDCTensor::reorder_tensor() –> void

serialize(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → pyrosetta.rosetta.utility.json_spirit.Value_impl_utility_json_spirit_Config_vector_std_string_t¶

serialize an RDCTensor to a json_spirit object

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

set_Dmax(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, Dmax: float) → None¶: C++: core::scoring::nmr::rdc::RDCTensor::set_Dmax(double) –> void

set_Eig_xx(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, Eig_xx: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_Eig_xx(double) –> void

set_Eig_yy(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, Eig_yy: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_Eig_yy(double) –> void

set_Eig_zz(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, Eig_zz: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_Eig_zz(double) –> void

set_T_xx(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, T_xx: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_T_xx(double) –> void

set_T_xy(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, T_xy: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_T_xy(double) –> void

set_T_xz(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, T_xz: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_T_xz(double) –> void

set_T_yy(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, T_yy: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_T_yy(double) –> void

set_T_yz(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, T_yz: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_T_yz(double) –> void

set_alpha(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, alpha: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_alpha(double) –> void

set_ax(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, ax: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_ax(double) –> void

set_beta(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, beta: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_beta(double) –> void

set_gamma(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, gamma: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_gamma(double) –> void

set_rh(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor, rh: float) → None¶: C++: core::scoring::nmr::NMRTensor::set_rh(double) –> void

set_tensor_in_arbitrary_frame(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, tensor_params: pyrosetta.rosetta.utility.vector1_double) → None¶

sets the alignment tensor as it exists in the arbitrary frame: resets the tensor upper diagonal elements vector should contain tensor parameters in the order A_xx, A_xy, A_xz, A_yy, A_yz

C++: core::scoring::nmr::rdc::RDCTensor::set_tensor_in_arbitrary_frame(const class utility::vector1<double, class std::allocator<double> > &) –> void

set_tensor_in_pas(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, tensor_params: pyrosetta.rosetta.utility.vector1_double) → None¶

sets the alignment tensor as it exists in the principal axis system (PAS): resets the alignment tensor principal values, the alignment order, the rhombicity, the three Euler angles and the dipolar coupling constant vector should contain tensor parameters in the order alpha, beta, gamma, Da, R, Dmax

C++: core::scoring::nmr::rdc::RDCTensor::set_tensor_in_pas(const class utility::vector1<double, class std::allocator<double> > &) –> void

show_tensor_stats(*args, **kwargs)¶

Overloaded function.

show_tensor_stats(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, TR: pyrosetta.rosetta.std.ostream) -> None
show_tensor_stats(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor, TR: pyrosetta.rosetta.std.ostream, show_in_pas: bool) -> None

shows summary of tensor statistics

If show_in_pas is true and tensor has been set or transformed in the
principal axis system, show tensor parameters in PAS. If either of the two conditions is not fulfilled show tensor matrix in arbitrary frame.

C++: core::scoring::nmr::rdc::RDCTensor::show_tensor_stats(std::ostream &, bool) const –> void

tensor_name(self: pyrosetta.rosetta.core.scoring.nmr.rdc.RDCTensor) → str¶

every tensor should offer a function that returns its name

C++: core::scoring::nmr::rdc::RDCTensor::tensor_name() const –> std::string

pyrosetta.rosetta.core.scoring.nmr.rdc.rdc_D_const(*args, **kwargs)¶

Overloaded function.

rdc_D_const(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) -> float
rdc_D_const(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE, correct_sign: bool) -> float

returns the dipolar coupling constant for two spins A and B in Hz/Ang^3: D_const = -(gA * gB * mu0 * hbar)/(4 * pi * pi) where gA, gB are the gyromagnetic ratios of the two spins and mu0 and hbar are the vacuum permeability and Planck’s constant / 2*pi From: Kramer et al. (2004) Concepts Magn Reson Part A, 21, 10-21 It is a common NMR convention to treat the sign of the 15N gyromagnetic ratio as positive. As a consequence the sign of dipolar couplings of experiments not involving 15N is flipped. To account for that, I flip here the sign of the CH and CC dipolar coupling constants. To turn this behavior off, the user can set the option “correct_sign” to true.

C++: core::scoring::nmr::rdc::rdc_D_const(const enum core::scoring::nmr::RDC_TYPE &, bool) –> double

pyrosetta.rosetta.core.scoring.nmr.rdc.rdc_D_max(*args, **kwargs)¶

Overloaded function.

rdc_D_max(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) -> float
rdc_D_max(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE, correct_sign: bool) -> float

returns the maximal dipolar coupling constant (in Hz) for a given spin pair A and B: taking into account a predefined distance r between A and B D_max = -(gA * gB * mu0 * hbar)/(4 * pi * pi * r^3) where gA, gB are the gyromagnetic ratios of the two spins and mu0 and hbar are the vacuum permeability and Planck’s constant / 2*pi From: Kramer et al. (2004) Concepts Magn Reson Part A, 21, 10-21 It is a common NMR convention to treat the sign of the 15N gyromagnetic ratio as positive. As a consequence the sign of dipolar couplings of experiments not involving 15N is flipped. To account for that, I flip here the sign of the CH and CC dipolar coupling constants. To turn this behavior off, the user can set the option “correct_sign” to true.

C++: core::scoring::nmr::rdc::rdc_D_max(const enum core::scoring::nmr::RDC_TYPE &, bool) –> double

pyrosetta.rosetta.core.scoring.nmr.rdc.rdc_erf(par: float, m_dat: int, data: capsule, fvec: float, : int) → None¶: C++: core::scoring::nmr::rdc::rdc_erf(const double *, int, const void *, double *, int *) –> void

pyrosetta.rosetta.core.scoring.nmr.rdc.rdc_ideal_bond_length(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) → float¶

returns the ideal bond length, in case this is not calculated from the pose

C++: core::scoring::nmr::rdc::rdc_ideal_bond_length(const enum core::scoring::nmr::RDC_TYPE &) –> double

pyrosetta.rosetta.core.scoring.nmr.rdc.rdc_scaling_factor_toCH(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) → float¶

returns the ratio (gA * gB) / (r * r * r) relative to CA-HA: this can be used to scale all RDC values relative to CAHA values in which case one general form of the RDC equation can be used Note that the 15N gyromagnetic ratio is treated as positive here. To account for the different signs of the NH and CH dipolar coupling constant, the option correct_sign can be used which changes the sign of Dconst.

C++: core::scoring::nmr::rdc::rdc_scaling_factor_toCH(const enum core::scoring::nmr::RDC_TYPE &) –> double

pyrosetta.rosetta.core.scoring.nmr.rdc.rdc_scaling_factor_toNH(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) → float¶

returns the ratio (gA * gB) / (r * r * r) relative to N-H: this can be used to scale all RDC values relative to NH values in which case one general form of the RDC equation can be used Note that the 15N gyromagnetic ratio is treated as positive here. To account for the different signs of the NH and CH dipolar coupling constant, the option correct_sign can be used which changes the sign of Dconst.

C++: core::scoring::nmr::rdc::rdc_scaling_factor_toNH(const enum core::scoring::nmr::RDC_TYPE &) –> double