noesy_assign

Bindings for protocols::noesy_assign namespace

class pyrosetta.rosetta.protocols.noesy_assign.CovalentCompliance

Bases: pyrosetta.rosetta.utility.SingletonBase_protocols_noesy_assign_CovalentCompliance_t

WARNING WARNING WARNING THIS SINGLETON CLASS HOLDS NON-CONST JOB-SPECIFIC DATA AND MAKES EVERYTHING THAT RELIES ON IT THREAD-UNSAFE. THIS IS NOT HOW SINGLETONS SHOULD BE USED.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

distance(self: pyrosetta.rosetta.protocols.noesy_assign.CovalentCompliance, atom1: pyrosetta.rosetta.core.id.NamedAtomID, atom2: pyrosetta.rosetta.core.id.NamedAtomID) → float

C++: protocols::noesy_assign::CovalentCompliance::distance(const class core::id::NamedAtomID &, const class core::id::NamedAtomID &) const –> double

get_instance() → protocols::noesy_assign::CovalentCompliance

C++: utility::SingletonBase<protocols::noesy_assign::CovalentCompliance>::get_instance() –> class protocols::noesy_assign::CovalentCompliance *

is_compliant(*args, **kwargs)

Overloaded function.

1. is_compliant(self: pyrosetta.rosetta.protocols.noesy_assign.CovalentCompliance, atom1: pyrosetta.rosetta.core.id.NamedAtomID, atom2: pyrosetta.rosetta.core.id.NamedAtomID) -> bool
2. is_compliant(self: pyrosetta.rosetta.protocols.noesy_assign.CovalentCompliance, atom1: pyrosetta.rosetta.core.id.NamedAtomID, atom2: pyrosetta.rosetta.core.id.NamedAtomID, cutoff: float) -> bool

C++: protocols::noesy_assign::CovalentCompliance::is_compliant(const class core::id::NamedAtomID &, const class core::id::NamedAtomID &, double) const –> bool

load_dist_table(self: pyrosetta.rosetta.protocols.noesy_assign.CovalentCompliance, file: str) → None

This is clearly thread-unsafe.

C++: protocols::noesy_assign::CovalentCompliance::load_dist_table(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo

Bases: pybind11_builtins.pybind11_object

shared information about CrossPeak (one for each proton dimension)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, cpi: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → bool

C++: protocols::noesy_assign::CrossPeakInfo::operator==(const class protocols::noesy_assign::CrossPeakInfo &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, proton: str, label: str, max_noe_distance: float, proton_tolerance: float, label_tolerance: float) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, arg0: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, : pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo

C++: protocols::noesy_assign::CrossPeakInfo::operator=(const class protocols::noesy_assign::CrossPeakInfo &) –> class protocols::noesy_assign::CrossPeakInfo &

exp_hash(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → int

C++: protocols::noesy_assign::CrossPeakInfo::exp_hash() const –> unsigned long

filename(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → str

C++: protocols::noesy_assign::CrossPeakInfo::filename() const –> const std::string &

fold_label_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → pyrosetta.rosetta.protocols.noesy_assign.FoldResonance

C++: protocols::noesy_assign::CrossPeakInfo::fold_label_resonance() const –> const class protocols::noesy_assign::FoldResonance &

fold_proton_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → pyrosetta.rosetta.protocols.noesy_assign.FoldResonance

C++: protocols::noesy_assign::CrossPeakInfo::fold_proton_resonance() const –> const class protocols::noesy_assign::FoldResonance &

has_label(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → bool

C++: protocols::noesy_assign::CrossPeakInfo::has_label() const –> bool

label_atom_name(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, proton_name: str, aa: pyrosetta.rosetta.core.chemical.AA) → str

C++: protocols::noesy_assign::CrossPeakInfo::label_atom_name(const class std::basic_string<char> &, enum core::chemical::AA) const –> std::string

label_atom_type(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → str

C++: protocols::noesy_assign::CrossPeakInfo::label_atom_type() const –> const std::string &

label_tolerance(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → float

C++: protocols::noesy_assign::CrossPeakInfo::label_tolerance() const –> const double &

main_atom(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → str

C++: protocols::noesy_assign::CrossPeakInfo::main_atom() const –> const std::string &

max_noe_distance(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → float

C++: protocols::noesy_assign::CrossPeakInfo::max_noe_distance() const –> double

proton_tolerance(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo) → float

C++: protocols::noesy_assign::CrossPeakInfo::proton_tolerance() const –> const double &

set_filename(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, filename: str) → None

C++: protocols::noesy_assign::CrossPeakInfo::set_filename(class std::basic_string<char>) –> void

set_folding_window(*args, **kwargs)

Overloaded function.

1. set_folding_window(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, start: float, end: float) -> None
2. set_folding_window(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, start: float, end: float, label: bool) -> None

C++: protocols::noesy_assign::CrossPeakInfo::set_folding_window(double, double, bool) –> void

set_label(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, label: str, tolerance: float) → None

C++: protocols::noesy_assign::CrossPeakInfo::set_label(class std::basic_string<char>, double) –> void

set_proton(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, name: str, tolerance: float) → None

C++: protocols::noesy_assign::CrossPeakInfo::set_proton(class std::basic_string<char>, double) –> void

show(self: pyrosetta.rosetta.protocols.noesy_assign.CrossPeakInfo, : pyrosetta.rosetta.std.ostream) → None

C++: protocols::noesy_assign::CrossPeakInfo::show(class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

maintains a list of constraints_ (each PeakAssignment yields one) and peak_constraints_ ( each cross peak with multiple assignments creates one AmbiguousNMRConstraint ). the DistanceMover (prepare scoring and apply directly interacts with the Dk term in CrossPeak (set_decoy_compatibility)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover, : pyrosetta.rosetta.protocols.noesy_assign.CrossPeakList, pose: pyrosetta.rosetta.core.pose.Pose, dcut: float) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover, arg0: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

apply(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

sum up decoy_compatibility score in PeakAssignments

C++: protocols::noesy_assign::DistanceScoreMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.moves.Mover, other: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::operator=(const class protocols::moves::Mover &) –> class protocols::moves::Mover &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

finalize_scoring(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover) → None

normalize decoy_compatibility of PeakAssignments by count_decoys_

C++: protocols::noesy_assign::DistanceScoreMover::finalize_scoring() const –> void

fresh_instance(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob

C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str

A tag is a unique identifier used to identify structures produced

by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover) → str

C++: protocols::noesy_assign::DistanceScoreMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str

C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

name() → str

C++: protocols::moves::Mover::name() –> std::string

prepare_scoring(*args, **kwargs)

Overloaded function.

1. prepare_scoring(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover) -> None
2. prepare_scoring(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover, use_for_calibration: bool) -> None

set decoy_compatibility in PeakAssignments to zero

C++: protocols::noesy_assign::DistanceScoreMover::prepare_scoring(bool) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

////////////////////////////end Job Distributor interface////////////////////////////////////////

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

C++: protocols::moves::Mover::set_current_tag(const class std::basic_string<char> &) –> void

set_dcut(self: pyrosetta.rosetta.protocols.noesy_assign.DistanceScoreMover, setting: float) → None

C++: protocols::noesy_assign::DistanceScoreMover::set_dcut(double) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(class std::basic_ostream<char> &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

C++: protocols::moves::Mover::type() const –> const std::string &

2. type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance

Bases: pyrosetta.rosetta.protocols.noesy_assign.Resonance

FloatingResonance combines resonanceID (label), chemical shift (freq), tolerance (error), and the assigned atom (atom, name, resid) (provided accessor methods of “FloatingResonance”: label, atom, resid, name, freq, error, tolerance, calibration_atom_type )

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, res: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.set_unsigned_long_t, : pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) -> None
3. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, arg0: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::_pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

aa(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.chemical.AA

C++: protocols::noesy_assign::Resonance::aa() const –> enum core::chemical::AA

add_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, ptr: pyrosetta.rosetta.std.weak_ptr_protocols_noesy_assign_Resonance_t) → None

C++: protocols::noesy_assign::Resonance::add_connected_resonance(class std::weak_ptr<class protocols::noesy_assign::Resonance>) –> void

ambiguity(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance) → int

C++: protocols::noesy_assign::FloatingResonance::ambiguity() const –> unsigned long

assign(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, : pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance) → pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance

C++: protocols::noesy_assign::FloatingResonance::operator=(const class protocols::noesy_assign::FloatingResonance &) –> class protocols::noesy_assign::FloatingResonance &

atom(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.id.NamedAtomID

Atom

C++: protocols::noesy_assign::Resonance::atom() const –> const class core::id::NamedAtomID &

calibration_atom_type(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.CALIBRATION_ATOM_TYPE

classification for calibration… e.g., Backbone, sidechain, etc..

C++: protocols::noesy_assign::Resonance::calibration_atom_type() const –> enum protocols::noesy_assign::CALIBRATION_ATOM_TYPE

clear_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → None

C++: protocols::noesy_assign::Resonance::clear_connected_resonances() –> void

clone(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::FloatingResonance::clone() –> class std::shared_ptr<class protocols::noesy_assign::Resonance>

connected_resonance_ids(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::noesy_assign::Resonance::connected_resonance_ids() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_noesy_assign_Resonance_t

C++: protocols::noesy_assign::Resonance::connected_resonances() const –> const class utility::vector1<class std::weak_ptr<class protocols::noesy_assign::Resonance>, class std::allocator<class std::weak_ptr<class protocols::noesy_assign::Resonance> > > &

error(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::error() const –> double

first_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::Resonance::first_connected_resonance() const –> const class protocols::noesy_assign::Resonance &

float_label(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, ifloat: int) → int

C++: protocols::noesy_assign::FloatingResonance::float_label(unsigned long) const –> unsigned long

freq(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

resonance frequency (chemical shift)

C++: protocols::noesy_assign::Resonance::freq() const –> double

has_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::has_connected_resonances() const –> bool

intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

in ILV-labelled proteins, the both LV methyls are labelled randomly with 50% probability,

whereas I delta methyls are labelled 100%

C++: protocols::noesy_assign::Resonance::intensity() const –> double

is_proton(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::is_proton() const –> bool

label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

ResonanceID

C++: protocols::noesy_assign::Resonance::label() const –> unsigned long

match(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → bool

Resonance matches the given cross-peaks frequency

C++: protocols::noesy_assign::Resonance::match(double, double, const class protocols::noesy_assign::FoldResonance &) const –> bool

match2D(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, proton_freq: float, proton_error: float, proton_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, label_freq: float, label_error: float, label_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, matches: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → bool

match the proton and corresponding label atom at same time

C++: protocols::noesy_assign::FloatingResonance::match2D(double, double, const class protocols::noesy_assign::FoldResonance &, double, double, const class protocols::noesy_assign::FoldResonance &, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> bool

name(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → str

C++: protocols::noesy_assign::Resonance::name() const –> const std::string &

pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, peakfreq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::FloatingResonance::pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

resid(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::resid() const –> unsigned long

set_intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, setting: float) → None

C++: protocols::noesy_assign::Resonance::set_intensity(double) –> void

tolerance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::tolerance() const –> double

write_to_stream(*args, **kwargs)

Overloaded function.

1. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, os: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::noesy_assign::FloatingResonance::write_to_stream(class std::basic_ostream<char> &) const –> void

2. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.FloatingResonance, : pyrosetta.rosetta.std.ostream, aa: pyrosetta.rosetta.core.chemical.AA) -> None

C++: protocols::noesy_assign::FloatingResonance::write_to_stream(class std::basic_ostream<char> &, enum core::chemical::AA) const –> void

class pyrosetta.rosetta.protocols.noesy_assign.LabelResonance

Bases: pyrosetta.rosetta.protocols.noesy_assign.Resonance

LabelResonance combines resonanceID (label), chemical shift (freq), tolerance (error), and the assigned atom (atom, name, resid) (provided accessor methods of “LabelResonance”: label, atom, resid, name, freq, error, tolerance, calibration_atom_type )

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance, label: int, freq: float, error: float, id: pyrosetta.rosetta.core.id.NamedAtomID, : pyrosetta.rosetta.core.chemical.AA, intensity: float) -> None
3. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance, arg0: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::_pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

aa(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.chemical.AA

C++: protocols::noesy_assign::Resonance::aa() const –> enum core::chemical::AA

add_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, ptr: pyrosetta.rosetta.std.weak_ptr_protocols_noesy_assign_Resonance_t) → None

C++: protocols::noesy_assign::Resonance::add_connected_resonance(class std::weak_ptr<class protocols::noesy_assign::Resonance>) –> void

ambiguity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::ambiguity() const –> unsigned long

assign(self: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance, : pyrosetta.rosetta.protocols.noesy_assign.LabelResonance) → pyrosetta.rosetta.protocols.noesy_assign.LabelResonance

C++: protocols::noesy_assign::LabelResonance::operator=(const class protocols::noesy_assign::LabelResonance &) –> class protocols::noesy_assign::LabelResonance &

atom(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.id.NamedAtomID

Atom

C++: protocols::noesy_assign::Resonance::atom() const –> const class core::id::NamedAtomID &

calibration_atom_type(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.CALIBRATION_ATOM_TYPE

classification for calibration… e.g., Backbone, sidechain, etc..

C++: protocols::noesy_assign::Resonance::calibration_atom_type() const –> enum protocols::noesy_assign::CALIBRATION_ATOM_TYPE

clear_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → None

C++: protocols::noesy_assign::Resonance::clear_connected_resonances() –> void

clone(self: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::LabelResonance::clone() –> class std::shared_ptr<class protocols::noesy_assign::Resonance>

connected_resonance_ids(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::noesy_assign::Resonance::connected_resonance_ids() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_noesy_assign_Resonance_t

C++: protocols::noesy_assign::Resonance::connected_resonances() const –> const class utility::vector1<class std::weak_ptr<class protocols::noesy_assign::Resonance>, class std::allocator<class std::weak_ptr<class protocols::noesy_assign::Resonance> > > &

error(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::error() const –> double

first_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::Resonance::first_connected_resonance() const –> const class protocols::noesy_assign::Resonance &

float_label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : int) → int

C++: protocols::noesy_assign::Resonance::float_label(unsigned long) const –> unsigned long

freq(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

resonance frequency (chemical shift)

C++: protocols::noesy_assign::Resonance::freq() const –> double

has_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::has_connected_resonances() const –> bool

intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

in ILV-labelled proteins, the both LV methyls are labelled randomly with 50% probability,

whereas I delta methyls are labelled 100%

C++: protocols::noesy_assign::Resonance::intensity() const –> double

is_proton(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::is_proton() const –> bool

label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

ResonanceID

C++: protocols::noesy_assign::Resonance::label() const –> unsigned long

match(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → bool

Resonance matches the given cross-peaks frequency

C++: protocols::noesy_assign::Resonance::match(double, double, const class protocols::noesy_assign::FoldResonance &) const –> bool

match2D(self: pyrosetta.rosetta.protocols.noesy_assign.LabelResonance, proton_freq: float, proton_error: float, proton_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, label_freq: float, label_error: float, label_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, matches: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → bool

match the proton and corresponding label atom at same time

C++: protocols::noesy_assign::LabelResonance::match2D(double, double, const class protocols::noesy_assign::FoldResonance &, double, double, const class protocols::noesy_assign::FoldResonance &, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> bool

name(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → str

C++: protocols::noesy_assign::Resonance::name() const –> const std::string &

pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

resid(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::resid() const –> unsigned long

set_intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, setting: float) → None

C++: protocols::noesy_assign::Resonance::set_intensity(double) –> void

tolerance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::tolerance() const –> double

write_to_stream(*args, **kwargs)

Overloaded function.

1. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.ostream) -> None

output

C++: protocols::noesy_assign::Resonance::write_to_stream(class std::basic_ostream<char> &) const –> void

2. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.ostream, aa: pyrosetta.rosetta.core.chemical.AA) -> None

C++: protocols::noesy_assign::Resonance::write_to_stream(class std::basic_ostream<char> &, enum core::chemical::AA) const –> void

class pyrosetta.rosetta.protocols.noesy_assign.NoesyModule

Bases: pybind11_builtins.pybind11_object

WARNING WARNING WARNING THREAD UNSAFE FOR USING THE COVALENTCOMPLIANCE CLASS IN A NON-CONST WAY

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, fasta_sequence: str) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, arg0: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_dist_viol_to_assignments(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, native_pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::noesy_assign::NoesyModule::add_dist_viol_to_assignments(class core::pose::Pose) –> void

assign(*args, **kwargs)

Overloaded function.

1. assign(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) -> None

same as above, but decoy file will be determined from commandline and read directly

C++: protocols::noesy_assign::NoesyModule::assign() –> void

2. assign(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, : pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) -> pyrosetta.rosetta.protocols.noesy_assign.NoesyModule

C++: protocols::noesy_assign::NoesyModule::operator=(const class protocols::noesy_assign::NoesyModule &) –> class protocols::noesy_assign::NoesyModule &

cmdline_options_activated() → bool

returns true if -noesy::in::resonances and -noesy::in::peaks are in cmd-line

C++: protocols::noesy_assign::NoesyModule::cmdline_options_activated() –> bool

crosspeaks(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) → pyrosetta.rosetta.protocols.noesy_assign.CrossPeakList

return (cross)peak-list (peak-file)

C++: protocols::noesy_assign::NoesyModule::crosspeaks() const –> const class protocols::noesy_assign::CrossPeakList &

generate_constraint_files(*args, **kwargs)

Overloaded function.

1. generate_constraint_files(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, pose: pyrosetta.rosetta.core.pose.Pose, cst_fa_file: str, cst_centroid_file: str, min_seq_separation: int) -> None
2. generate_constraint_files(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, pose: pyrosetta.rosetta.core.pose.Pose, cst_fa_file: str, cst_centroid_file: str, min_seq_separation: int, min_quali: int) -> None
3. generate_constraint_files(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, pose: pyrosetta.rosetta.core.pose.Pose, cst_fa_file: str, cst_centroid_file: str, min_seq_separation: int, min_quali: int, max_quali: int) -> None
4. generate_constraint_files(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, pose: pyrosetta.rosetta.core.pose.Pose, cst_fa_file: str, cst_centroid_file: str, min_seq_separation: int, min_quali: int, max_quali: int, ignore_elimination_candidates: bool) -> None
5. generate_constraint_files(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, pose: pyrosetta.rosetta.core.pose.Pose, cst_fa_file: str, cst_centroid_file: str, min_seq_separation: int, min_quali: int, max_quali: int, ignore_elimination_candidates: bool, elimination_candidates: bool) -> None

after assignment –> create appropriate constraints

C++: protocols::noesy_assign::NoesyModule::generate_constraint_files(const class core::pose::Pose &, const class std::basic_string<char> &, const class std::basic_string<char> &, unsigned long, unsigned long, unsigned long, bool, bool) const –> void

register_options() → None

register options

C++: protocols::noesy_assign::NoesyModule::register_options() –> void

reset(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) → None

reset assignments… – call before re-assigning peaks

C++: protocols::noesy_assign::NoesyModule::reset() –> void

sequence(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) → str

C++: protocols::noesy_assign::NoesyModule::sequence() –> const std::string &

write_assignments(*args, **kwargs)

Overloaded function.

1. write_assignments(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule) -> None
2. write_assignments(self: pyrosetta.rosetta.protocols.noesy_assign.NoesyModule, file: str) -> None

write assignments into peak-file…

C++: protocols::noesy_assign::NoesyModule::write_assignments(class std::basic_string<char>) –> void

class pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment

Bases: pybind11_builtins.pybind11_object

fast access to assignments that are stored in CrossPeak – similar to FragID WARNING WARNING WARNING THREAD UNSAFE. THIS CLASS USES THE FUNCTION covalent_compliance WHICH RELIES ON THREAD-UNSAFE SINGLETON CovalentCompliance

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, other: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → bool

C++: protocols::noesy_assign::PeakAssignment::operator==(const class protocols::noesy_assign::PeakAssignment &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, : pyrosetta.rosetta.protocols.noesy_assign.CrossPeak, assign_spin1: int, assign_spin2: int) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, arg0: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, : pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment

C++: protocols::noesy_assign::PeakAssignment::operator=(const class protocols::noesy_assign::PeakAssignment &) –> class protocols::noesy_assign::PeakAssignment &

atom(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, iatom: int) → pyrosetta.rosetta.core.id.NamedAtomID

returns atom 1 or 2 of the assigned cross-peak. — might throw Exception if atom not found in ResonanceList

C++: protocols::noesy_assign::PeakAssignment::atom(unsigned long) const –> const class core::id::NamedAtomID &

calibration_atom_type(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, iatom: int) → pyrosetta.rosetta.protocols.noesy_assign.CALIBRATION_ATOM_TYPE

C++: protocols::noesy_assign::PeakAssignment::calibration_atom_type(unsigned long) const –> enum protocols::noesy_assign::CALIBRATION_ATOM_TYPE

chemshift_compliance(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

C++: protocols::noesy_assign::PeakAssignment::chemshift_compliance() const –> double

create_constraint(*args, **kwargs)

Overloaded function.

1. create_constraint(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
2. create_constraint(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.func.Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: protocols::noesy_assign::PeakAssignment::create_constraint(const class core::pose::Pose &, class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

3. create_constraint(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, pose: pyrosetta.rosetta.core.pose.Pose, ifloat: int) -> pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint
4. create_constraint(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, pose: pyrosetta.rosetta.core.pose.Pose, ifloat: int, : pyrosetta.rosetta.core.scoring.func.Func) -> pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint

C++: protocols::noesy_assign::PeakAssignment::create_constraint(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::AmbiguousNMRDistanceConstraint>

crosspeak(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → pyrosetta.rosetta.protocols.noesy_assign.CrossPeak

C++: protocols::noesy_assign::PeakAssignment::crosspeak() –> class protocols::noesy_assign::CrossPeak &

decoy_compatibility(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

C++: protocols::noesy_assign::PeakAssignment::decoy_compatibility() const –> double

dump_weights(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, os: pyrosetta.rosetta.std.ostream) → None

C++: protocols::noesy_assign::PeakAssignment::dump_weights(class std::basic_ostream<char> &) const –> void

float_ambiguity(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → int

C++: protocols::noesy_assign::PeakAssignment::float_ambiguity() const –> unsigned long

has_label(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, select: int) → bool

C++: protocols::noesy_assign::PeakAssignment::has_label(unsigned long) const –> bool

has_proton(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, select: int) → bool

C++: protocols::noesy_assign::PeakAssignment::has_proton(unsigned long) const –> bool

is_symmetric_partner_of(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, other: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → bool

C++: protocols::noesy_assign::PeakAssignment::is_symmetric_partner_of(const class protocols::noesy_assign::PeakAssignment &) const –> bool

label_atom(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, iatom: int) → pyrosetta.rosetta.core.id.NamedAtomID

C++: protocols::noesy_assign::PeakAssignment::label_atom(unsigned long) const –> const class core::id::NamedAtomID &

label_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, iatom: int) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::PeakAssignment::label_resonance(unsigned long) const –> const class protocols::noesy_assign::Resonance &

label_resonance_id(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, select: int) → int

return resonance_id, i.e., pointer into Resonance list that will resolve in assigned atom

C++: protocols::noesy_assign::PeakAssignment::label_resonance_id(unsigned long) const –> unsigned long

native_distance_viol(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

C++: protocols::noesy_assign::PeakAssignment::native_distance_viol() –> double

network_anchoring(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

C++: protocols::noesy_assign::PeakAssignment::network_anchoring() const –> double

network_anchoring_per_residue(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

C++: protocols::noesy_assign::PeakAssignment::network_anchoring_per_residue() const –> double

normalized_peak_volume(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

only correct if peak_volumes have been update in CrossPeaks.

C++: protocols::noesy_assign::PeakAssignment::normalized_peak_volume() const –> double

peak_volume(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

this is not normalized

C++: protocols::noesy_assign::PeakAssignment::peak_volume() const –> double

resid(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, iatom: int) → int

returns residue number of a1 or a2 of the assigned cross-peak, — might throw Exception if atom not found

C++: protocols::noesy_assign::PeakAssignment::resid(unsigned long) const –> unsigned long

resonance(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, iatom: int) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::PeakAssignment::resonance(unsigned long) const –> const class protocols::noesy_assign::Resonance &

resonance_id(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, select: int) → int

return resonance_id, i.e., pointer into Resonance list that will resolve in assigned atom

C++: protocols::noesy_assign::PeakAssignment::resonance_id(unsigned long) const –> unsigned long

resonances(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → pyrosetta.rosetta.protocols.noesy_assign.ResonanceList

C++: protocols::noesy_assign::PeakAssignment::resonances() const –> const class protocols::noesy_assign::ResonanceList &

set_decoy_compatibility(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, setting: float) → None

C++: protocols::noesy_assign::PeakAssignment::set_decoy_compatibility(double) –> void

set_native_distance_viol(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, setting: float) → None

C++: protocols::noesy_assign::PeakAssignment::set_native_distance_viol(double) –> void

set_network_anchoring(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, setting: float) → None

C++: protocols::noesy_assign::PeakAssignment::set_network_anchoring(double) –> void

set_network_anchoring_per_residue(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, reswise_setting: float) → None

C++: protocols::noesy_assign::PeakAssignment::set_network_anchoring_per_residue(double) –> void

set_symmetry(*args, **kwargs)

Overloaded function.

1. set_symmetry(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) -> None
2. set_symmetry(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, setting: float) -> None

C++: protocols::noesy_assign::PeakAssignment::set_symmetry(double) –> void

show(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, os: pyrosetta.rosetta.std.ostream) → None

C++: protocols::noesy_assign::PeakAssignment::show(class std::basic_ostream<char> &) const –> void

spin_id(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment, select: int) → int

C++: protocols::noesy_assign::PeakAssignment::spin_id(unsigned long) const –> unsigned long

symmetry_compliance(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → float

C++: protocols::noesy_assign::PeakAssignment::symmetry_compliance() const –> double

update_chemshiftscore_from_peak(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → None

C++: protocols::noesy_assign::PeakAssignment::update_chemshiftscore_from_peak() –> void

update_upperdistance_score(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → None

C++: protocols::noesy_assign::PeakAssignment::update_upperdistance_score() –> void

class pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap

Bases: pybind11_builtins.pybind11_object

fast access to assignments by residue number

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add(*args, **kwargs)

Overloaded function.

1. add(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, : pyrosetta.rosetta.protocols.noesy_assign.CrossPeakList) -> None

add all PeakAssignments in all Crosspeaks of list

C++: protocols::noesy_assign::PeakAssignmentResidueMap::add(const class protocols::noesy_assign::CrossPeakList &) –> void

2. add(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, : pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) -> None

add individual PeakAssignment

C++: protocols::noesy_assign::PeakAssignmentResidueMap::add(const class std::shared_ptr<class protocols::noesy_assign::PeakAssignment> &) –> void

add_all_atoms(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, : pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → None

add all resonances for backward compatibility in covalent-part of network-analysis

C++: protocols::noesy_assign::PeakAssignmentResidueMap::add_all_atoms(const class protocols::noesy_assign::ResonanceList &) –> void

assign(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, : pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap) → pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap

C++: protocols::noesy_assign::PeakAssignmentResidueMap::operator=(const class protocols::noesy_assign::PeakAssignmentResidueMap &) –> class protocols::noesy_assign::PeakAssignmentResidueMap &

assignments(*args, **kwargs)

Overloaded function.

1. assignments(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, resi: int, resj: int) -> pyrosetta.rosetta.std.list_std_shared_ptr_protocols_noesy_assign_PeakAssignment_std_allocator_std_shared_ptr_protocols_noesy_assign_PeakAssignment_t

C++: protocols::noesy_assign::PeakAssignmentResidueMap::assignments(unsigned long, unsigned long) –> class std::list<class std::shared_ptr<class protocols::noesy_assign::PeakAssignment>, class std::allocator<class std::shared_ptr<class protocols::noesy_assign::PeakAssignment> > > &

2. assignments(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, resi: int, resj: int, collector: pyrosetta.rosetta.std.list_std_shared_ptr_protocols_noesy_assign_PeakAssignment_std_allocator_std_shared_ptr_protocols_noesy_assign_PeakAssignment_t) -> None

add assignments found between resi and resj to collector

C++: protocols::noesy_assign::PeakAssignmentResidueMap::assignments(unsigned long, unsigned long, class std::list<class std::shared_ptr<class protocols::noesy_assign::PeakAssignment>, class std::allocator<class std::shared_ptr<class protocols::noesy_assign::PeakAssignment> > > &) const –> void

check_for_symmetric_peaks(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, : pyrosetta.rosetta.protocols.noesy_assign.CrossPeakList, accumulate_symmetry: bool) → None

invalidate non symmetric peaks

C++: protocols::noesy_assign::PeakAssignmentResidueMap::check_for_symmetric_peaks(class protocols::noesy_assign::CrossPeakList &, bool) –> void

has(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, resi: int, resj: int) → bool

has some (valid or invalid) assignments between residue pair

C++: protocols::noesy_assign::PeakAssignmentResidueMap::has(unsigned long, unsigned long) –> bool

network_analysis(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, n_total_assignments: int) → None

C++: protocols::noesy_assign::PeakAssignmentResidueMap::network_analysis(unsigned long) –> void

network_analysis2(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap) → None

C++: protocols::noesy_assign::PeakAssignmentResidueMap::network_analysis2() –> void

remove(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap, : pyrosetta.rosetta.protocols.noesy_assign.PeakAssignment) → None

remove individual PeakAssignment

C++: protocols::noesy_assign::PeakAssignmentResidueMap::remove(const class protocols::noesy_assign::PeakAssignment &) –> void

total_residue(self: pyrosetta.rosetta.protocols.noesy_assign.PeakAssignmentResidueMap) → int

C++: protocols::noesy_assign::PeakAssignmentResidueMap::total_residue() const –> unsigned long

class pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance

Bases: pyrosetta.rosetta.protocols.noesy_assign.Resonance

ProtonResonance combines resonanceID (label), chemical shift (freq), tolerance (error), and the assigned atom (atom, name, resid) (provided accessor methods of “ProtonResonance”: label, atom, resid, name, freq, error, tolerance, calibration_atom_type )

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance, label: int, freq: float, error: float, id: pyrosetta.rosetta.core.id.NamedAtomID, : pyrosetta.rosetta.core.chemical.AA, intensity: float) -> None
3. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance, arg0: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::_pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

aa(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.chemical.AA

C++: protocols::noesy_assign::Resonance::aa() const –> enum core::chemical::AA

add_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, ptr: pyrosetta.rosetta.std.weak_ptr_protocols_noesy_assign_Resonance_t) → None

C++: protocols::noesy_assign::Resonance::add_connected_resonance(class std::weak_ptr<class protocols::noesy_assign::Resonance>) –> void

ambiguity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::ambiguity() const –> unsigned long

assign(self: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance, : pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance) → pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance

C++: protocols::noesy_assign::ProtonResonance::operator=(const class protocols::noesy_assign::ProtonResonance &) –> class protocols::noesy_assign::ProtonResonance &

atom(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.id.NamedAtomID

Atom

C++: protocols::noesy_assign::Resonance::atom() const –> const class core::id::NamedAtomID &

calibration_atom_type(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.CALIBRATION_ATOM_TYPE

classification for calibration… e.g., Backbone, sidechain, etc..

C++: protocols::noesy_assign::Resonance::calibration_atom_type() const –> enum protocols::noesy_assign::CALIBRATION_ATOM_TYPE

clear_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → None

C++: protocols::noesy_assign::Resonance::clear_connected_resonances() –> void

clone(self: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::ProtonResonance::clone() –> class std::shared_ptr<class protocols::noesy_assign::Resonance>

connected_resonance_ids(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::noesy_assign::Resonance::connected_resonance_ids() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_noesy_assign_Resonance_t

C++: protocols::noesy_assign::Resonance::connected_resonances() const –> const class utility::vector1<class std::weak_ptr<class protocols::noesy_assign::Resonance>, class std::allocator<class std::weak_ptr<class protocols::noesy_assign::Resonance> > > &

error(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::error() const –> double

first_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::Resonance::first_connected_resonance() const –> const class protocols::noesy_assign::Resonance &

float_label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : int) → int

C++: protocols::noesy_assign::Resonance::float_label(unsigned long) const –> unsigned long

freq(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

resonance frequency (chemical shift)

C++: protocols::noesy_assign::Resonance::freq() const –> double

has_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::has_connected_resonances() const –> bool

intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

in ILV-labelled proteins, the both LV methyls are labelled randomly with 50% probability,

whereas I delta methyls are labelled 100%

C++: protocols::noesy_assign::Resonance::intensity() const –> double

is_proton(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::is_proton() const –> bool

label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

ResonanceID

C++: protocols::noesy_assign::Resonance::label() const –> unsigned long

match(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → bool

Resonance matches the given cross-peaks frequency

C++: protocols::noesy_assign::Resonance::match(double, double, const class protocols::noesy_assign::FoldResonance &) const –> bool

match2D(self: pyrosetta.rosetta.protocols.noesy_assign.ProtonResonance, proton_freq: float, proton_error: float, proton_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, label_freq: float, label_error: float, label_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, matches: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → bool

match the proton and corresponding label atom at same time

C++: protocols::noesy_assign::ProtonResonance::match2D(double, double, const class protocols::noesy_assign::FoldResonance &, double, double, const class protocols::noesy_assign::FoldResonance &, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> bool

name(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → str

C++: protocols::noesy_assign::Resonance::name() const –> const std::string &

pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

resid(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::resid() const –> unsigned long

set_intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, setting: float) → None

C++: protocols::noesy_assign::Resonance::set_intensity(double) –> void

tolerance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::tolerance() const –> double

write_to_stream(*args, **kwargs)

Overloaded function.

1. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.ostream) -> None

output

C++: protocols::noesy_assign::Resonance::write_to_stream(class std::basic_ostream<char> &) const –> void

2. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.ostream, aa: pyrosetta.rosetta.core.chemical.AA) -> None

C++: protocols::noesy_assign::Resonance::write_to_stream(class std::basic_ostream<char> &, enum core::chemical::AA) const –> void

class pyrosetta.rosetta.protocols.noesy_assign.Resonance

Bases: pybind11_builtins.pybind11_object

Resonance combines resonanceID (label), chemical shift (freq), tolerance (error), and the assigned atom (atom, name, resid) (provided accessor methods of “Resonance”: label, atom, resid, name, freq, error, tolerance, calibration_atom_type )

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) -> None
2. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, arg0: int, arg1: float, arg2: float, arg3: pyrosetta.rosetta.core.id.NamedAtomID, arg4: pyrosetta.rosetta.core.chemical.AA) -> None

doc

3. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, label: int, freq: float, error: float, id: pyrosetta.rosetta.core.id.NamedAtomID, : pyrosetta.rosetta.core.chemical.AA, intensity: float) -> None
4. __init__(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, arg0: pyrosetta.rosetta.protocols.noesy_assign.Resonance) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::_pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

aa(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.chemical.AA

C++: protocols::noesy_assign::Resonance::aa() const –> enum core::chemical::AA

add_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, ptr: pyrosetta.rosetta.std.weak_ptr_protocols_noesy_assign_Resonance_t) → None

C++: protocols::noesy_assign::Resonance::add_connected_resonance(class std::weak_ptr<class protocols::noesy_assign::Resonance>) –> void

ambiguity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::ambiguity() const –> unsigned long

assign(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::Resonance::operator=(const class protocols::noesy_assign::Resonance &) –> class protocols::noesy_assign::Resonance &

atom(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.core.id.NamedAtomID

Atom

C++: protocols::noesy_assign::Resonance::atom() const –> const class core::id::NamedAtomID &

calibration_atom_type(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.CALIBRATION_ATOM_TYPE

classification for calibration… e.g., Backbone, sidechain, etc..

C++: protocols::noesy_assign::Resonance::calibration_atom_type() const –> enum protocols::noesy_assign::CALIBRATION_ATOM_TYPE

clear_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → None

C++: protocols::noesy_assign::Resonance::clear_connected_resonances() –> void

clone(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::Resonance::clone() –> class std::shared_ptr<class protocols::noesy_assign::Resonance>

connected_resonance_ids(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::noesy_assign::Resonance::connected_resonance_ids() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_noesy_assign_Resonance_t

C++: protocols::noesy_assign::Resonance::connected_resonances() const –> const class utility::vector1<class std::weak_ptr<class protocols::noesy_assign::Resonance>, class std::allocator<class std::weak_ptr<class protocols::noesy_assign::Resonance> > > &

error(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::error() const –> double

first_connected_resonance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → pyrosetta.rosetta.protocols.noesy_assign.Resonance

C++: protocols::noesy_assign::Resonance::first_connected_resonance() const –> const class protocols::noesy_assign::Resonance &

float_label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : int) → int

C++: protocols::noesy_assign::Resonance::float_label(unsigned long) const –> unsigned long

freq(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

resonance frequency (chemical shift)

C++: protocols::noesy_assign::Resonance::freq() const –> double

has_connected_resonances(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::has_connected_resonances() const –> bool

intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

in ILV-labelled proteins, the both LV methyls are labelled randomly with 50% probability,

whereas I delta methyls are labelled 100%

C++: protocols::noesy_assign::Resonance::intensity() const –> double

is_proton(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → bool

C++: protocols::noesy_assign::Resonance::is_proton() const –> bool

label(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

ResonanceID

C++: protocols::noesy_assign::Resonance::label() const –> unsigned long

match(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → bool

Resonance matches the given cross-peaks frequency

C++: protocols::noesy_assign::Resonance::match(double, double, const class protocols::noesy_assign::FoldResonance &) const –> bool

match2D(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, proton_freq: float, proton_error: float, proton_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, label_freq: float, label_error: float, label_folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance, matches: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t) → bool

match the proton and corresponding label atom at same time

C++: protocols::noesy_assign::Resonance::match2D(double, double, const class protocols::noesy_assign::FoldResonance &, double, double, const class protocols::noesy_assign::FoldResonance &, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> bool

name(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → str

C++: protocols::noesy_assign::Resonance::name() const –> const std::string &

pmatch(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, freq: float, error: float, folder: pyrosetta.rosetta.protocols.noesy_assign.FoldResonance) → float

C++: protocols::noesy_assign::Resonance::pmatch(double, double, const class protocols::noesy_assign::FoldResonance &) const –> double

resid(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → int

C++: protocols::noesy_assign::Resonance::resid() const –> unsigned long

set_intensity(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, setting: float) → None

C++: protocols::noesy_assign::Resonance::set_intensity(double) –> void

tolerance(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance) → float

C++: protocols::noesy_assign::Resonance::tolerance() const –> double

write_to_stream(*args, **kwargs)

Overloaded function.

1. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.ostream) -> None

output

C++: protocols::noesy_assign::Resonance::write_to_stream(class std::basic_ostream<char> &) const –> void

2. write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.Resonance, : pyrosetta.rosetta.std.ostream, aa: pyrosetta.rosetta.core.chemical.AA) -> None

C++: protocols::noesy_assign::Resonance::write_to_stream(class std::basic_ostream<char> &, enum core::chemical::AA) const –> void

class pyrosetta.rosetta.protocols.noesy_assign.ResonanceList

Bases: pybind11_builtins.pybind11_object

: the ResonanceList provides a map of chemical shifts. each atom-chemical shift tupel has a “resonanceID” as a key. (integer)

used classes:

Resonance is an atom with chemical shift information ResonanceIDs (typedef) is a map from ID to Resonance ResidueMap (typedef) is a map from residue number to a vector of Resonances.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getitem__(*args, **kwargs)

Overloaded function.

1. __getitem__(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, key: int) -> pyrosetta.rosetta.protocols.noesy_assign.Resonance

retrieve a Resonance by ResonanceID — throws EXCN_UnknonwResonance if atom not found

C++: protocols::noesy_assign::ResonanceList::operator[](unsigned long) const –> const class protocols::noesy_assign::Resonance &

2. __getitem__(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, : pyrosetta.rosetta.core.id.NamedAtomID) -> pyrosetta.rosetta.protocols.noesy_assign.Resonance

retrive a Resonance by atom — throws EXCN_UnknonwResonance if atom not found

C++: protocols::noesy_assign::ResonanceList::operator[](const class core::id::NamedAtomID &) const –> const class protocols::noesy_assign::Resonance &

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, sequence: str) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

aa_from_resid(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, resi: int) → pyrosetta.rosetta.core.chemical.AA

retrieve aminoacid of residue “resi”

C++: protocols::noesy_assign::ResonanceList::aa_from_resid(unsigned long) const –> enum core::chemical::AA

begin(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<protocols::noesy_assign::Resonance> > >

C++: protocols::noesy_assign::ResonanceList::begin() const –> struct std::_Rb_tree_const_iterator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::noesy_assign::Resonance> > >

end(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<protocols::noesy_assign::Resonance> > >

C++: protocols::noesy_assign::ResonanceList::end() const –> struct std::_Rb_tree_const_iterator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::noesy_assign::Resonance> > >

has_residue(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, resi: int) → bool

have at least one resonance for residue “resi”

C++: protocols::noesy_assign::ResonanceList::has_residue(unsigned long) const –> bool

last_key(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → int

last ResonanceID ( given by input file )

C++: protocols::noesy_assign::ResonanceList::last_key() const –> unsigned long

read_from_stream(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, : pyrosetta.rosetta.std.istream) → None

read chemical shift assignments

C++: protocols::noesy_assign::ResonanceList::read_from_stream(class std::basic_istream<char> &) –> void

resonances_at_residue(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, resid: int) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_noesy_assign_Resonance_t

all resonances of a certain residue

— requires that update_residue_map() has been called (which is done by read_from_stream() )

C++: protocols::noesy_assign::ResonanceList::resonances_at_residue(unsigned long) const –> const class utility::vector1<class std::shared_ptr<class protocols::noesy_assign::Resonance>, class std::allocator<class std::shared_ptr<class protocols::noesy_assign::Resonance> > > &

sequence(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → str

retrieve the protein sequence

C++: protocols::noesy_assign::ResonanceList::sequence() const –> const std::string &

size(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → int

number of Resonances

C++: protocols::noesy_assign::ResonanceList::size() const –> unsigned long

start_key(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList) → int

first ResonanceID (given by input file)

C++: protocols::noesy_assign::ResonanceList::start_key() const –> unsigned long

write_talos_format(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, : pyrosetta.rosetta.std.ostream, backbone_only: bool) → None

write in talos format

C++: protocols::noesy_assign::ResonanceList::write_talos_format(class std::basic_ostream<char> &, bool) const –> void

write_to_stream(self: pyrosetta.rosetta.protocols.noesy_assign.ResonanceList, : pyrosetta.rosetta.std.ostream) → None

write chemical shift assignments

C++: protocols::noesy_assign::ResonanceList::write_to_stream(class std::basic_ostream<char> &) const –> void

pyrosetta.rosetta.protocols.noesy_assign.covalent_compliance(atom1: pyrosetta.rosetta.core.id.NamedAtomID, atom2: pyrosetta.rosetta.core.id.NamedAtomID) → bool

WARNING WARNING WARNING THREAD UNSAFE covalent_compliance RELIES ON THREAD-UNSAFE SINGLETON CovalentCompliance

C++: protocols::noesy_assign::covalent_compliance(const class core::id::NamedAtomID &, const class core::id::NamedAtomID &) –> bool