pcs

Bindings for core::scoring::nmr::pcs namespace

class pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData

Bases: CacheableData

assign(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData, rhs: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData) → pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData

assignment operator

C++: core::scoring::nmr::pcs::PCSData::operator=(const class core::scoring::nmr::pcs::PCSData &) –> class core::scoring::nmr::pcs::PCSData &

clone(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData) → pyrosetta.rosetta.basic.datacache.CacheableData

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

get_number_tags(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData) → int

C++: core::scoring::nmr::pcs::PCSData::get_number_tags() const –> unsigned long

get_pcs_multiset_vec(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_nmr_pcs_PCSMultiSet_t

C++: core::scoring::nmr::pcs::PCSData::get_pcs_multiset_vec() –> class utility::vector1<class std::shared_ptr<class core::scoring::nmr::pcs::PCSMultiSet>, class std::allocator<class std::shared_ptr<class core::scoring::nmr::pcs::PCSMultiSet> > > &

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_pcs(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData) → int

C++: core::scoring::nmr::pcs::PCSData::get_total_number_pcs() const –> unsigned long

optimize_tensors(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSData) → bool

C++: core::scoring::nmr::pcs::PCSData::optimize_tensors() const –> bool

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

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

class pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet, rhs: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet

assignment operator

C++: core::scoring::nmr::pcs::PCSMultiSet::operator=(const class core::scoring::nmr::pcs::PCSMultiSet &) –> class core::scoring::nmr::pcs::PCSMultiSet &

fix_tensors(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → None

C++: core::scoring::nmr::pcs::PCSMultiSet::fix_tensors() –> void

get_gridsearch_iterator(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → pyrosetta.rosetta.core.scoring.nmr.NMRGridSearch

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

get_number_metal_ions(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → int

C++: core::scoring::nmr::pcs::PCSMultiSet::get_number_metal_ions() const –> unsigned long

get_pcs_singleset_vec(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_scoring_nmr_pcs_PCSSingleSet_t

C++: core::scoring::nmr::pcs::PCSMultiSet::get_pcs_singleset_vec() –> class utility::vector1<class std::shared_ptr<class core::scoring::nmr::pcs::PCSSingleSet>, class std::allocator<class std::shared_ptr<class core::scoring::nmr::pcs::PCSSingleSet> > > &

get_spinlabel(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → pyrosetta.rosetta.core.scoring.nmr.NMRSpinlabel

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

get_tag_residue_number(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → int

C++: core::scoring::nmr::pcs::PCSMultiSet::get_tag_residue_number() const –> unsigned long

get_total_number_pcs(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → int

C++: core::scoring::nmr::pcs::PCSMultiSet::get_total_number_pcs() const –> unsigned long

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → float

C++: core::scoring::nmr::pcs::PCSMultiSet::get_weight() const –> double

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

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

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

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

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

C++: core::scoring::nmr::pcs::PCSMultiSet::set_weight(double) –> void

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

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

tensors_fixed(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → bool

C++: core::scoring::nmr::pcs::PCSMultiSet::tensors_fixed() const –> bool

unfix_tensors(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSMultiSet) → None

C++: core::scoring::nmr::pcs::PCSMultiSet::unfix_tensors() –> void

class pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle, rhs: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle) → pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle

assignment operator

C++: core::scoring::nmr::pcs::PCSSingle::operator=(const class core::scoring::nmr::pcs::PCSSingle &) –> class core::scoring::nmr::pcs::PCSSingle &

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

C++: core::scoring::nmr::pcs::PCSSingle::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.pcs.PCSSingle) → pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

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

get_pcs_calc(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle) → float

C++: core::scoring::nmr::pcs::PCSSingle::get_pcs_calc() const –> double

get_pcs_err(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle) → float

C++: core::scoring::nmr::pcs::PCSSingle::get_pcs_err() const –> double

get_pcs_exp(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle) → float

C++: core::scoring::nmr::pcs::PCSSingle::get_pcs_exp() const –> double

get_protein_spins(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::scoring::nmr::pcs::PCSSingle::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.pcs.PCSSingle) → float

C++: core::scoring::nmr::pcs::PCSSingle::get_weight() const –> double

serialize(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle) → pyrosetta.rosetta.utility.json_spirit.Value_impl_utility_json_spirit_Config_vector_std_string_t

serialize a PCSSingle object to a json_spirit object

C++: core::scoring::nmr::pcs::PCSSingle::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.pcs.PCSSingle, idx: int, fdx: float, fdy: float, fdz: float) → None

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

set_pcs_calc(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle, calc: float) → None

C++: core::scoring::nmr::pcs::PCSSingle::set_pcs_calc(double) –> void

set_pcs_err(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle, err: float) → None

C++: core::scoring::nmr::pcs::PCSSingle::set_pcs_err(double) –> void

set_pcs_exp(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingle, pcs: float) → None

C++: core::scoring::nmr::pcs::PCSSingle::set_pcs_exp(double) –> void

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

C++: core::scoring::nmr::pcs::PCSSingle::set_weight(double) –> void

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

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

class pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet

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 NLSAX = non-linear least squares fitting with fixed axial tensor component NLSRH = non-linear least squares fitting with fixed rhombic tensor component NLSAXRH = non-linear least squares fitting with fixed axial and rhombic tensor component

Members:

SVD

NLS

NLSAX

NLSRH

NLSAXRH

NLS = <COMPUTATION_TYPE.NLS: 2>

NLSAX = <COMPUTATION_TYPE.NLSAX: 3>

NLSAXRH = <COMPUTATION_TYPE.NLSAXRH: 5>

NLSRH = <COMPUTATION_TYPE.NLSRH: 4>

SVD = <COMPUTATION_TYPE.SVD: 1>

property name

property value

NLS = <COMPUTATION_TYPE.NLS: 2>

NLSAX = <COMPUTATION_TYPE.NLSAX: 3>

NLSAXRH = <COMPUTATION_TYPE.NLSAXRH: 5>

NLSRH = <COMPUTATION_TYPE.NLSRH: 4>

SVD = <COMPUTATION_TYPE.SVD: 1>

assign(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, rhs: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet

assignment operator

C++: core::scoring::nmr::pcs::PCSSingleSet::operator=(const class core::scoring::nmr::pcs::PCSSingleSet &) –> class core::scoring::nmr::pcs::PCSSingleSet &

compute_pcs_values_and_score_from_tensor(*args, **kwargs)

Overloaded function.

1. compute_pcs_values_and_score_from_tensor(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, tensor: core::scoring::nmr::pcs::PCSTensor) -> float

calculate PCS values from a given tensor, set values in the PCSSingle vector

and return the PCS score

C++: core::scoring::nmr::pcs::PCSSingleSet::compute_pcs_values_and_score_from_tensor(const class core::scoring::nmr::pcs::PCSTensor &) –> double

2. compute_pcs_values_and_score_from_tensor(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) -> float

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

C++: core::scoring::nmr::pcs::PCSSingleSet::compute_pcs_values_and_score_from_tensor() –> double

get_averaging_type(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.core.scoring.nmr.NMR_VALUE_AVERAGING_TYPE

C++: core::scoring::nmr::pcs::PCSSingleSet::get_averaging_type() const –> enum core::scoring::nmr::NMR_VALUE_AVERAGING_TYPE

get_computation_type(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet.COMPUTATION_TYPE

C++: core::scoring::nmr::pcs::PCSSingleSet::get_computation_type() const –> enum core::scoring::nmr::pcs::PCSSingleSet::COMPUTATION_TYPE

get_dataset_name(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → str

C++: core::scoring::nmr::pcs::PCSSingleSet::get_dataset_name() const –> std::string

get_matrix_A(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.ObjexxFCL.FArray2D_double_t

C++: core::scoring::nmr::pcs::PCSSingleSet::get_matrix_A() const –> const class ObjexxFCL::FArray2D<double> &

get_metal_coord_bounds(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.utility.fixedsizearray1_double_6_t

C++: core::scoring::nmr::pcs::PCSSingleSet::get_metal_coord_bounds() const –> const class utility::fixedsizearray1<double, 6> &

get_metal_ion_label(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → str

C++: core::scoring::nmr::pcs::PCSSingleSet::get_metal_ion_label() const –> std::string

get_number_pcs(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → int

C++: core::scoring::nmr::pcs::PCSSingleSet::get_number_pcs() const –> unsigned long

get_pcs_single_weights(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t

C++: core::scoring::nmr::pcs::PCSSingleSet::get_pcs_single_weights() const –> const class ObjexxFCL::FArray1D<double> &

get_pcs_values(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.ObjexxFCL.FArray1D_double_t

C++: core::scoring::nmr::pcs::PCSSingleSet::get_pcs_values() const –> const class ObjexxFCL::FArray1D<double> &

get_scaling_factor(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → float

C++: core::scoring::nmr::pcs::PCSSingleSet::get_scaling_factor() const –> double

get_single_pcs_vec(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → pyrosetta.rosetta.utility.vector1_core_scoring_nmr_pcs_PCSSingle

C++: core::scoring::nmr::pcs::PCSSingleSet::get_single_pcs_vec() const –> const class utility::vector1<class core::scoring::nmr::pcs::PCSSingle, class std::allocator<class core::scoring::nmr::pcs::PCSSingle> > &

get_spin_coordinates(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → 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::pcs::PCSSingleSet::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_tensor(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → core::scoring::nmr::pcs::PCSTensor

C++: core::scoring::nmr::pcs::PCSSingleSet::get_tensor() –> class std::shared_ptr<class core::scoring::nmr::pcs::PCSTensor>

get_tensor_const(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → core::scoring::nmr::pcs::PCSTensor

C++: core::scoring::nmr::pcs::PCSSingleSet::get_tensor_const() const –> class std::shared_ptr<const class core::scoring::nmr::pcs::PCSTensor>

get_weight(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → float

C++: core::scoring::nmr::pcs::PCSSingleSet::get_weight() const –> double

normalized_data(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → bool

C++: core::scoring::nmr::pcs::PCSSingleSet::normalized_data() const –> bool

set_atom_derivatives(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, pose: pyrosetta.rosetta.core.pose.Pose) → None

sets the xyz derivative of the PCS

PCSTensor 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::pcs::PCSSingleSet::set_atom_derivatives(class core::pose::Pose &) –> void

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

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

set_computation_type(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, type: str) → None

C++: core::scoring::nmr::pcs::PCSSingleSet::set_computation_type(const std::string &) –> void

set_metal_coord_bounds(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, metal_coord_bounds: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) → None

C++: core::scoring::nmr::pcs::PCSSingleSet::set_metal_coord_bounds(const class utility::fixedsizearray1<double, 6> &) –> void

set_tensor(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, tensor: core::scoring::nmr::pcs::PCSTensor) → None

C++: core::scoring::nmr::pcs::PCSSingleSet::set_tensor(const class std::shared_ptr<class core::scoring::nmr::pcs::PCSTensor> &) –> void

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

C++: core::scoring::nmr::pcs::PCSSingleSet::set_weight(double) –> void

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

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

solve_tensor_and_compute_score_by_nls(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, metal_coord: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

solves the PCS tensor using NLS and returns the weighted PCS score

according to the single PCS weighting scheme

C++: core::scoring::nmr::pcs::PCSSingleSet::solve_tensor_and_compute_score_by_nls(const class numeric::xyzVector<double> &) –> double

solve_tensor_and_compute_score_by_svd(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, metal_coord: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

solves the PCS tensor using SVD and returns the weighted PCS score

according to the single PCS weighting scheme

C++: core::scoring::nmr::pcs::PCSSingleSet::solve_tensor_and_compute_score_by_svd(const class numeric::xyzVector<double> &) –> double

symmetric_pcs_calc(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet) → bool

C++: core::scoring::nmr::pcs::PCSSingleSet::symmetric_pcs_calc() const –> bool

update_matrix_A(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, metal_coord: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

updates matrix_A using the metal coordinates it gets from

the grid search of the PCSMultiSet object hands matrix_A over to the SVD solver too

C++: core::scoring::nmr::pcs::PCSSingleSet::update_matrix_A(const class numeric::xyzVector<double> &) –> void

update_spin_coordinates(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSSingleSet, 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::pcs::PCSSingleSet::update_spin_coordinates(const class core::pose::Pose &) –> void

class pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor

Bases: NMRTensor

assign(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor, rhs: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor

assignment operator

C++: core::scoring::nmr::pcs::PCSTensor::operator=(const class core::scoring::nmr::pcs::PCSTensor &) –> class core::scoring::nmr::pcs::PCSTensor &

deserialize(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor, 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 PCSTensor

C++: core::scoring::nmr::pcs::PCSTensor::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.pcs.PCSTensor) → None

brings tensor in principal axis frame by diagonalization

make sure to call either set_tensor_in_arbitrary_frame() or set_tensor_in_pas() first

C++: core::scoring::nmr::pcs::PCSTensor::diagonalize_tensor() –> void

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_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_metal_center(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::nmr::pcs::PCSTensor::get_metal_center() const –> const class numeric::xyzVector<double> &

get_rh(self: pyrosetta.rosetta.core.scoring.nmr.NMRTensor) → float

C++: core::scoring::nmr::NMRTensor::get_rh() const –> double

is_pcs_tensor_diagonalized(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → bool

C++: core::scoring::nmr::pcs::PCSTensor::is_pcs_tensor_diagonalized() const –> bool

is_pcs_tensor_in_arbitrary_frame(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → bool

C++: core::scoring::nmr::pcs::PCSTensor::is_pcs_tensor_in_arbitrary_frame() const –> bool

is_pcs_tensor_in_pas(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → bool

C++: core::scoring::nmr::pcs::PCSTensor::is_pcs_tensor_in_pas() const –> bool

is_pcs_tensor_reconfigured(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → bool

C++: core::scoring::nmr::pcs::PCSTensor::is_pcs_tensor_reconfigured() const –> bool

reorder_tensor(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → None

brings delta chi tensor principal values in correct order

and reconfigures tensor into unique tensor representation make sure to call set_tensor_in_pas() or diagonalize_tensor() first

C++: core::scoring::nmr::pcs::PCSTensor::reorder_tensor() –> void

serialize(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → pyrosetta.rosetta.utility.json_spirit.Value_impl_utility_json_spirit_Config_vector_std_string_t

serialize a PCSTensor to a json_spirit object

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

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_metal_center(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor, xM: float, yM: float, zM: float) → None

C++: core::scoring::nmr::pcs::PCSTensor::set_metal_center(double, double, 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.pcs.PCSTensor, tensor_params: pyrosetta.rosetta.utility.vector1_double) → None

sets the delta chi tensor as it exists in the arbitrary frame

resets the tensor upper diagonal elements and the coordinates of the metal center parameters in vector should be in order chi__xx, chi_xy, chi_xz, chi_yy, chi_yz, xM, yM, zM

C++: core::scoring::nmr::pcs::PCSTensor::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.pcs.PCSTensor, tensor_params: pyrosetta.rosetta.utility.vector1_double) → None

sets the delta chi tensor as it exists in the principal axis system (PAS)

resets the tensor principal values, the axial and rhombic component, the three Euler angles and the coordinates of the metal center parameters in vector should be in order alpha, beta, gamma, xM, yM, zM, ax, rh

C++: core::scoring::nmr::pcs::PCSTensor::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.pcs.PCSTensor, TR: pyrosetta.rosetta.std.ostream) -> None

2. show_tensor_stats(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor, 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::pcs::PCSTensor::show_tensor_stats(std::ostream &, bool) const –> void

tensor_name(self: pyrosetta.rosetta.core.scoring.nmr.pcs.PCSTensor) → str

every tensor should offer a function that returns its name

C++: core::scoring::nmr::pcs::PCSTensor::tensor_name() const –> std::string

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

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