rdc

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

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

Bases: pyrosetta.rosetta.basic.datacache.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_builtins.pybind11_object

class COMPUTATION_TYPE

Bases: pybind11_builtins.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
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.

  1. 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

  1. 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_builtins.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) 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_builtins.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: pyrosetta.rosetta.core.scoring.nmr.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) 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.

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

  2. 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.

  1. rdc_D_const(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) -> float

  2. 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.

  1. rdc_D_max(type: pyrosetta.rosetta.core.scoring.nmr.RDC_TYPE) -> float

  2. 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