antibody¶

Bindings for protocols::antibody namespace

class pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo¶

Bases: pybind11_object

Specifically for AntibodyModeling protocol templates. Not for general use.

assign(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, : pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) → pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo¶: C++: protocols::antibody::Ab_TemplateInfo::operator=(const class protocols::antibody::Ab_TemplateInfo &) –> class protocols::antibody::Ab_TemplateInfo &

get_one_template_pose(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, cdr_name: str) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::antibody::Ab_TemplateInfo::get_one_template_pose(std::string) –> class core::pose::Pose

is_camelid(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) → bool¶: C++: protocols::antibody::Ab_TemplateInfo::is_camelid() –> bool

load_templates_from_pdbs(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, load_L1: bool, load_L2: bool, load_L3: bool, load_H1: bool, load_H2: bool, load_H3: bool, camelid: bool) → None¶: C++: protocols::antibody::Ab_TemplateInfo::load_templates_from_pdbs(bool, bool, bool, bool, bool, bool, bool) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo) -> None
show(self: pyrosetta.rosetta.protocols.antibody.Ab_TemplateInfo, out: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::Ab_TemplateInfo::show(std::ostream &) –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter¶

Bases: Mover

Class to graft CDR loops from an antibody to a new antibody or from a CDR pose into a different antibody.: Independant of antibody and CDR modeling. Results in 100 percent loop closure if using both graft algorithms.

Recommended to use cluster-based or general dihedral constraints on the CDR with a min or relax to optimize graft. Use optimiize_cdrs option to optimize the CDRs that were grafted and any neighbor CDRs using these dihedral constraints during relax.

By default, uses two residues on N and C terminal of insert CDR and scaffold to close loop. Use getters of primary and secondary graft mover to change this if needed. By default, stops after the graft is closed!

apply(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::AntibodyCDRGrafter::apply(class core::pose::Pose &) –> void

apply_to_cdr(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, pose: pyrosetta.rosetta.core.pose.Pose, cdr_region_with_overhang: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, grafter: protocols::grafting::AnchoredGraftMover) → Tuple[bool, int]¶

Apply graft mover to pose, inserting the cdr_region.

Return success or failure of the graft and the position of the failure. Public in case one wants to use it by itself…

C++: protocols::antibody::AntibodyCDRGrafter::apply_to_cdr(class core::pose::Pose &, class core::pose::Pose &, const enum protocols::antibody::CDRNameEnum, class std::shared_ptr<class protocols::grafting::AnchoredGraftMover>) –> struct std::pair<bool, unsigned long>

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, : pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter¶: C++: protocols::antibody::AntibodyCDRGrafter::operator=(const class protocols::antibody::AntibodyCDRGrafter &) –> class protocols::antibody::AntibodyCDRGrafter &

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.antibody.AntibodyCDRGrafter) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::AntibodyCDRGrafter::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>

fresh_instance(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::AntibodyCDRGrafter::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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.AntibodyCDRGrafter) → str¶: C++: protocols::antibody::AntibodyCDRGrafter::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_primary_graft_mover(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → protocols::grafting::CCDEndsGraftMover¶

Get a reference of the main graft mover to tweak settings.

C++: protocols::antibody::AntibodyCDRGrafter::get_primary_graft_mover() –> class protocols::grafting::CCDEndsGraftMover &

get_secondary_graft_mover(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter) → protocols::grafting::AnchoredGraftMover¶

Get a reference of the secondary graft mover to tweak settings.

C++: protocols::antibody::AntibodyCDRGrafter::get_secondary_graft_mover() –> class protocols::grafting::AnchoredGraftMover &

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_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

static mover_name() → str¶: C++: protocols::antibody::AntibodyCDRGrafter::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::antibody::AntibodyCDRGrafter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::antibody::AntibodyCDRGrafter::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyCDRGrafter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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_cdr_only(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶

Set a single CDR we are going to graft in.

C++: protocols::antibody::AntibodyCDRGrafter::set_cdr_only(enum protocols::antibody::CDRNameEnum) –> void

set_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, cdrs: pyrosetta.rosetta.utility.vector1_bool) → None¶

Set the CDRs to graft. Boolean vector of CDRNameEnums (1-8) (includes CDR4/DE loop)

C++: protocols::antibody::AntibodyCDRGrafter::set_cdrs(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_dihedral_constraint_weight(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, dih_cst_wt: float) → None¶

Set the dihedral constraint weight used if optimization is done and the scorefxn dihedral_constraint: weight is zero. Default = 2.0

C++: protocols::antibody::AntibodyCDRGrafter::set_dihedral_constraint_weight(double) –> void

set_donor_structure(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set a donor structure. Culd be a single CDR, multiple CDRs or a whole other antibody.

C++: protocols::antibody::AntibodyCDRGrafter::set_donor_structure(const class core::pose::Pose &) –> void

set_idealize_insert(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, idealize_insert: bool) → None¶

Idealize the insert. Default TRUE.

C++: protocols::antibody::AntibodyCDRGrafter::set_idealize_insert(bool) –> void

set_include_cdr4_in_optimization(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, include_cdr4: bool) → None¶

Set to include the DE loop, or CDR4 if it is a neighbor to a grafted CDR and optimization is set to on.: Recommended if optimizing. Default TRUE.

C++: protocols::antibody::AntibodyCDRGrafter::set_include_cdr4_in_optimization(bool) –> 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_optimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, optimize_cdrs: bool) → None¶

Set to optimize any grafted and neighbor CDRs using dihdedral constrained relax on them. Default FALSE.: Recommended if using secondary graft mover.

C++: protocols::antibody::AntibodyCDRGrafter::set_optimize_cdrs(bool) –> void

set_overhang(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, nter_overhang: int, cter_overhang: int) → None¶

Set the N and Cterminal overhang used for superposition before the graft.

C++: protocols::antibody::AntibodyCDRGrafter::set_overhang(unsigned long, unsigned long) –> void

set_scorefxn_low(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the (low-res) scorefunction used by the graft movers to close loop.: Default is to use Frank Dimaio’s smoothed low-res terms.

C++: protocols::antibody::AntibodyCDRGrafter::set_scorefxn_low(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_scorefxn_pack(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set the (all-atom) scorefunction used by the graft movers for packing: Otherwise use cmd-line default

C++: protocols::antibody::AntibodyCDRGrafter::set_scorefxn_pack(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_stop_after_closure(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, stop_after_closure: bool) → None¶

Set a boolean for whether to stop after closure or not. Default TRUE.

C++: protocols::antibody::AntibodyCDRGrafter::set_stop_after_closure(bool) –> void

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

Set the ‘type’ string

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

set_use_secondary_graft_mover_if_needed(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafter, use_secondary_graft_mover: bool) → None¶

Set a boolean for whether to use the secondary graft mover is the graft is not closed using the first.

Default FALSE.

Using this results in 100% graft closure, however, in order to fix the structure, a dihedral constrained relax is done on the CDR while repacking neighbor residues. 85% Graft closure without (slight chainbreaks - not as bad as what used to be used for antibody modeling.)

C++: protocols::antibody::AntibodyCDRGrafter::set_use_secondary_graft_mover_if_needed(bool) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator, : pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator) → pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator¶: C++: protocols::antibody::AntibodyCDRGrafterCreator::operator=(const class protocols::antibody::AntibodyCDRGrafterCreator &) –> class protocols::antibody::AntibodyCDRGrafterCreator &

create_mover(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::AntibodyCDRGrafterCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator) → str¶: C++: protocols::antibody::AntibodyCDRGrafterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.antibody.AntibodyCDRGrafterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyCDRGrafterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager¶

Bases: pybind11_object

Class responsible for loading information from the AntibodyDatabase.

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, : pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager) → pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager¶: C++: protocols::antibody::AntibodyDatabaseManager::operator=(const class protocols::antibody::AntibodyDatabaseManager &) –> class protocols::antibody::AntibodyDatabaseManager &

clone(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager) → pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager¶: C++: protocols::antibody::AntibodyDatabaseManager::clone() const –> class std::shared_ptr<class protocols::antibody::AntibodyDatabaseManager>

ignore_light_chain(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, ignore_light_chain: bool) → None¶: C++: protocols::antibody::AntibodyDatabaseManager::ignore_light_chain(const bool) –> void

load_cdr_design_data(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, pose: pyrosetta.rosetta.core.pose.Pose, prob_set: pyrosetta.rosetta.std.map_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t_std_allocator_std_pair_const_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t, cutoff: int) → pyrosetta.rosetta.utility.vector1_bool¶

Load probability data for CDR Design. Returns CDRs where data could not be loaded. Cutoff indicates number of total sequences needed to use the data.

Will attempt to use Pose Datacache for identification of CDR clusters first.

C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_design_data(const class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > > &, const class core::pose::Pose &, class std::map<unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > > > > > &, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

load_cdr_design_data_for_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, cdrs: pyrosetta.rosetta.utility.vector1_bool, pose: pyrosetta.rosetta.core.pose.Pose, prob_set: pyrosetta.rosetta.std.map_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t_std_allocator_std_pair_const_unsigned_long_std_map_core_chemical_AA_double_std_less_core_chemical_AA_std_allocator_std_pair_const_core_chemical_AA_double_t, cutoff: int) → pyrosetta.rosetta.utility.vector1_bool¶: C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_design_data_for_cdrs(const class utility::vector1<bool, class std::allocator<bool> > &, const class core::pose::Pose &, class std::map<unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<enum core::chemical::AA, double, struct std::less<enum core::chemical::AA>, class std::allocator<struct std::pair<const enum core::chemical::AA, double> > > > > > &, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

load_cdr_pose(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, db_pose: pyrosetta.rosetta.protocols.antibody.CDRDBPose) → pyrosetta.rosetta.core.pose.Pose¶

Load a single pose into the db_pose using the given struct_id. If failure, it is nullptr

C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_pose(struct protocols::antibody::CDRDBPose &) –> class std::shared_ptr<class core::pose::Pose>

load_cdr_poses(*args, **kwargs)¶

Overloaded function.

load_cdr_poses(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBPose_std_allocator_protocols_antibody_CDRDBPose_t_std_allocator_std_pair_const_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBPose_std_allocator_protocols_antibody_CDRDBPose_t
load_cdr_poses(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t, pose: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> pyrosetta.rosetta.std.map_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBPose_std_allocator_protocols_antibody_CDRDBPose_t_std_allocator_std_pair_const_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBPose_std_allocator_protocols_antibody_CDRDBPose_t

Load CDRs from options of all cdrs..

Will attempt to use Pose Datacache for identification of CDR clusters first.

C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_poses(const class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > > &, const class core::pose::Pose &, unsigned long) –> class std::map<enum protocols::antibody::CDRNameEnum, class utility::vector1<struct protocols::antibody::CDRDBPose, class std::allocator<struct protocols::antibody::CDRDBPose> >, struct std::less<enum protocols::antibody::CDRNameEnum>, class std::allocator<struct std::pair<const enum protocols::antibody::CDRNameEnum, class utility::vector1<struct protocols::antibody::CDRDBPose, class std::allocator<struct protocols::antibody::CDRDBPose> > > > >

load_cdr_sequences(*args, **kwargs)¶

Overloaded function.

load_cdr_sequences(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, cdrs: pyrosetta.rosetta.utility.vector1_bool, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.std.map_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBSequence_std_allocator_protocols_antibody_CDRDBSequence_t_std_allocator_std_pair_const_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBSequence_std_allocator_protocols_antibody_CDRDBSequence_t
load_cdr_sequences(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, cdrs: pyrosetta.rosetta.utility.vector1_bool, pose: pyrosetta.rosetta.core.pose.Pose, match_on_length: bool) -> pyrosetta.rosetta.std.map_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBSequence_std_allocator_protocols_antibody_CDRDBSequence_t_std_allocator_std_pair_const_protocols_antibody_CDRNameEnum_utility_vector1_protocols_antibody_CDRDBSequence_std_allocator_protocols_antibody_CDRDBSequence_t

Load a set of CDR sequences from the database

C++: protocols::antibody::AntibodyDatabaseManager::load_cdr_sequences(const class utility::vector1<bool, class std::allocator<bool> > &, const class core::pose::Pose &, bool) –> class std::map<enum protocols::antibody::CDRNameEnum, class utility::vector1<struct protocols::antibody::CDRDBSequence, class std::allocator<struct protocols::antibody::CDRDBSequence> >, struct std::less<enum protocols::antibody::CDRNameEnum>, class std::allocator<struct std::pair<const enum protocols::antibody::CDRNameEnum, class utility::vector1<struct protocols::antibody::CDRDBSequence, class std::allocator<struct protocols::antibody::CDRDBSequence> > > > >

set_outlier_use(self: pyrosetta.rosetta.protocols.antibody.AntibodyDatabaseManager, use_outliers: bool) → None¶

Set to parse outliers for both sequence and structural data. Default False.

C++: protocols::antibody::AntibodyDatabaseManager::set_outlier_use(bool) –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager¶

Bases: pybind11_object

Interface to this class is in AntibodyInfo.

all_cdrs(*args, **kwargs)¶

Overloaded function.

all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum
all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, include_proto_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

C++: protocols::antibody::AntibodyEnumManager::all_cdrs(bool) –> const class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> > &

antibody_region_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, antibody_region: pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::antibody_region_enum_to_string(const enum protocols::antibody::AntibodyRegionEnum) const –> std::string

antibody_region_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, antibody_region: str) → pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum¶

////////////// Antibody Region ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::antibody_region_string_to_enum(const std::string &) const –> enum protocols::antibody::AntibodyRegionEnum

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, : pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) → pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager¶: C++: protocols::antibody::AntibodyEnumManager::operator=(const class protocols::antibody::AntibodyEnumManager &) –> class protocols::antibody::AntibodyEnumManager &

cdr_definition_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_definition: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::cdr_definition_enum_to_string(const enum protocols::antibody::CDRDefinitionEnum) const –> std::string

cdr_definition_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_definition: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::cdr_definition_is_present(const std::string &) const –> bool

cdr_definition_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_definition: str) → pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum¶

/////////////// CDR Definitions ///////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::cdr_definition_string_to_enum(const std::string &) const –> enum protocols::antibody::CDRDefinitionEnum

cdr_landmark_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, landmark: pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::cdr_landmark_enum_to_string(const enum protocols::antibody::CDRLandmarkEnum) const –> std::string

cdr_landmark_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, landmark: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::cdr_landmark_is_present(const std::string &) const –> bool

cdr_landmark_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, landmark: str) → pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum¶

////////////// Antibody Landmarks ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::cdr_landmark_string_to_enum(const std::string &) const –> enum protocols::antibody::CDRLandmarkEnum

cdr_name_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::cdr_name_enum_to_string(const enum protocols::antibody::CDRNameEnum) const –> std::string

cdr_name_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_name: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::cdr_name_is_present(const std::string &) const –> bool

cdr_name_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, cdr_name: str) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶

/////////////// CDR names ///////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::cdr_name_string_to_enum(const std::string &) const –> enum protocols::antibody::CDRNameEnum

get_recognized_cdr_definitions(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) → pyrosetta.rosetta.utility.vector1_std_string¶: C++: protocols::antibody::AntibodyEnumManager::get_recognized_cdr_definitions() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_recognized_numbering_schemes(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager) → pyrosetta.rosetta.utility.vector1_std_string¶: C++: protocols::antibody::AntibodyEnumManager::get_recognized_numbering_schemes() const –> class utility::vector1<std::string, class std::allocator<std::string > >

h3_base_type_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, base_type: pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::h3_base_type_enum_to_string(const enum protocols::antibody::H3BaseTypeEnum) const –> std::string

h3_base_type_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, base_type: str) → pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum¶

/////////////// H3 Base Type ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::h3_base_type_string_to_enum(const std::string &) const –> enum protocols::antibody::H3BaseTypeEnum

light_chain_type_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, light_chain: pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::light_chain_type_enum_to_string(const enum protocols::antibody::LightChainTypeEnum) const –> std::string

light_chain_type_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, light_chain: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::light_chain_type_is_present(const std::string &) const –> bool

light_chain_type_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, light_chain: str) → pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum¶

////////////// LightChain Types ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::light_chain_type_string_to_enum(const std::string &) const –> enum protocols::antibody::LightChainTypeEnum

numbering_scheme_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, numbering_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::numbering_scheme_enum_to_string(const enum protocols::antibody::AntibodyNumberingSchemeEnum) const –> std::string

numbering_scheme_is_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, numbering_scheme: str) → bool¶: C++: protocols::antibody::AntibodyEnumManager::numbering_scheme_is_present(const std::string &) const –> bool

numbering_scheme_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, numbering_scheme: str) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum¶

/////////////// Numbering Schemes ///////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::numbering_scheme_string_to_enum(const std::string &) const –> enum protocols::antibody::AntibodyNumberingSchemeEnum

packing_angle_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, angle_type: pyrosetta.rosetta.protocols.antibody.PackingAngleEnum) → str¶: C++: protocols::antibody::AntibodyEnumManager::packing_angle_enum_to_string(const enum protocols::antibody::PackingAngleEnum) const –> std::string

packing_angle_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager, angle_type: str) → pyrosetta.rosetta.protocols.antibody.PackingAngleEnum¶

////////////// Packing Angle ////////////////////////////////////////////

C++: protocols::antibody::AntibodyEnumManager::packing_angle_string_to_enum(const std::string &) const –> enum protocols::antibody::PackingAngleEnum

class pyrosetta.rosetta.protocols.antibody.AntibodyFeatures¶

Bases: InterfaceFeatures

Collects data on an antibody including CDRs, interfaces of L_H, L_A, H_A, and LH_A (this can be set), and other metrics.

Adds …. tables to the database. See also protocols/antibody/clusters/CDRClusterFeatures

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, : pyrosetta.rosetta.protocols.antibody.AntibodyFeatures) → pyrosetta.rosetta.protocols.antibody.AntibodyFeatures¶: C++: protocols::antibody::AntibodyFeatures::operator=(const class protocols::antibody::AntibodyFeatures &) –> class protocols::antibody::AntibodyFeatures &

check_relevant_residues(*args, **kwargs)¶

Overloaded function.

check_relevant_residues(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, res1: int) -> bool

C++: protocols::features::FeaturesReporter::check_relevant_residues(const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) const –> bool

check_relevant_residues(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, res1: int, res2: int) -> bool

C++: protocols::features::FeaturesReporter::check_relevant_residues(const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, unsigned long) const –> bool

check_relevant_residues(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, residues: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: protocols::features::FeaturesReporter::check_relevant_residues(const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

check_relevant_residues_range(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, res1: int, res2: int) → bool¶: C++: protocols::features::FeaturesReporter::check_relevant_residues_range(const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, unsigned long) const –> bool

static class_name() → str¶: C++: protocols::antibody::AntibodyFeatures::class_name() –> std::string

delete_record(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, : int, : pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::FeaturesReporter::delete_record(unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> void

features_reporter_dependencies(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures) → pyrosetta.rosetta.utility.vector1_std_string¶

return the set of features reporters that are required to also already be extracted by the time this one is used.

C++: protocols::features::InterfaceFeatures::features_reporter_dependencies() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_relevant_residues_mode(self: pyrosetta.rosetta.protocols.features.FeaturesReporter) → pyrosetta.rosetta.protocols.features.RelevantResiduesMode.T¶: C++: protocols::features::FeaturesReporter::get_relevant_residues_mode() const –> enum protocols::features::RelevantResiduesMode::T

load_into_pose(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, : pyrosetta.rosetta.utility.sql_database.session, : int, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::features::FeaturesReporter::load_into_pose(class std::shared_ptr<class utility::sql_database::session>, unsigned long, class core::pose::Pose &) –> void

make_interface_combos(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, interfaces: pyrosetta.rosetta.utility.vector1_std_string) → None¶

Gets all possible interface combinations of a given pose.

C++: protocols::features::InterfaceFeatures::make_interface_combos(const class core::pose::Pose &, class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::antibody::AntibodyFeatures::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyFeatures::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report_ab_H3_kink_metrics_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::report_ab_H3_kink_metrics_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> void

report_ab_metrics_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::report_ab_metrics_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> void

report_all_interface_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, interface: str, db_interface: str) → None¶

Report all features. Called by report_features. Easy interface for subclassing specific interfaces.

interface is the interface analyzed, db_interface is the name that is actually inserted into the database Usually this is the same, but useful when dealing with different chain ids but same interface type. db_interface should have sides as well (L_H))

C++: protocols::features::InterfaceFeatures::report_all_interface_features(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const std::string &, const std::string &) –> void

report_cdr_metrics_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶: C++: protocols::antibody::AntibodyFeatures::report_cdr_metrics_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const enum protocols::antibody::CDRNameEnum &) –> void

report_cdr_residue_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, relevant_residues: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: protocols::antibody::AntibodyFeatures::report_cdr_residue_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const enum protocols::antibody::CDRNameEnum &, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

report_cdr_residue_features_row(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, resnum: int, position: int) → None¶: C++: protocols::antibody::AntibodyFeatures::report_cdr_residue_features_row(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const enum protocols::antibody::CDRNameEnum &, unsigned long, unsigned long) –> void

report_features(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, pose: pyrosetta.rosetta.core.pose.Pose, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session) → int¶

collect all the feature data for the pose

C++: protocols::antibody::AntibodyFeatures::report_features(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, class std::shared_ptr<class utility::sql_database::session>) –> unsigned long

report_interface_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, chains_side1: str, chains_side2: str) → None¶

Add interfaces table data to table

C++: protocols::features::InterfaceFeatures::report_interface_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const std::string &, const std::string &) const –> void

report_interface_residue_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, relevant_residues: pyrosetta.rosetta.utility.vector1_bool, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, chains_side1: str, chains_side2: str) → None¶

Add interface_residues data to table

C++: protocols::features::InterfaceFeatures::report_interface_residue_features(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const std::string &, const std::string &) const –> void

report_interface_side_features(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pose: pyrosetta.rosetta.core.pose.Pose, struct_id: int, db_session: pyrosetta.rosetta.utility.sql_database.session, chains_side1: str, chains_side2: str, region: pyrosetta.rosetta.protocols.analysis.InterfaceRegion, region_string: str) → None¶

Add interface_sides table data to table

C++: protocols::features::InterfaceFeatures::report_interface_side_features(const class core::pose::Pose &, unsigned long, class std::shared_ptr<class utility::sql_database::session>, const std::string &, const std::string &, enum protocols::analysis::InterfaceRegion, const std::string &) const –> void

schema(self: pyrosetta.rosetta.protocols.features.FeaturesReporter) → str¶

return sql statements that sets up the appropriate tables to contain the features. This should be removed once everything has been moved to the schema generator

C++: protocols::features::FeaturesReporter::schema() const –> std::string

set_ab_info(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, ab_info: protocols::antibody::AntibodyInfo) → None¶: C++: protocols::antibody::AntibodyFeatures::set_ab_info(class std::shared_ptr<class protocols::antibody::AntibodyInfo>) –> void

set_compute_packstat(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, compute_packstat: bool) → None¶

Compute the packstat score? Default true

C++: protocols::features::InterfaceFeatures::set_compute_packstat(const bool) –> void

set_dSASA_cutoff(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, dSASA_cutoff: float) → None¶

Set the reporter to only include interfaces >dSASA_cutoff.

C++: protocols::features::InterfaceFeatures::set_dSASA_cutoff(double) –> void

set_defaults(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures) → None¶: C++: protocols::features::InterfaceFeatures::set_defaults() –> void

set_interface_chains(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, intermediate_interfaces: pyrosetta.rosetta.utility.vector1_std_string) → None¶

Set intermediate interface chains: Example: L_A, H_A, L_H, LH_A (A stands for antigen)

Any other chains, use InterfaceFeatures.

C++: protocols::antibody::AntibodyFeatures::set_interface_chains(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

set_pack_separated(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pack_separated: bool) → None¶

Pack the interface before separation? Default is false.

C++: protocols::features::InterfaceFeatures::set_pack_separated(const bool) –> void

set_pack_together(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, pack_together: bool) → None¶

Pack the interface after separation? Default is true.

C++: protocols::features::InterfaceFeatures::set_pack_together(const bool) –> void

set_relevant_residues_mode(self: pyrosetta.rosetta.protocols.features.FeaturesReporter, setting: pyrosetta.rosetta.protocols.features.RelevantResiduesMode.T) → None¶: C++: protocols::features::FeaturesReporter::set_relevant_residues_mode(enum protocols::features::RelevantResiduesMode::T) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::features::InterfaceFeatures::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

type_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures) → str¶: C++: protocols::antibody::AntibodyFeatures::type_name() const –> std::string

write_ab_H3_kink_metrics_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶

Write kink metrics schema. Please add or modify as needed.

C++: protocols::antibody::AntibodyFeatures::write_ab_H3_kink_metrics_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_ab_metrics_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::write_ab_metrics_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_cdr_metrics_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::write_cdr_metrics_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_cdr_residue_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::antibody::AntibodyFeatures::write_cdr_residue_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_interface_residues_schema_to_db(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::InterfaceFeatures::write_interface_residues_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_interface_schema_to_db(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::InterfaceFeatures::write_interface_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_interface_side_schema_to_db(self: pyrosetta.rosetta.protocols.features.InterfaceFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶: C++: protocols::features::InterfaceFeatures::write_interface_side_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

write_schema_to_db(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeatures, db_session: pyrosetta.rosetta.utility.sql_database.session) → None¶

return string with class name

C++: protocols::antibody::AntibodyFeatures::write_schema_to_db(class std::shared_ptr<class utility::sql_database::session>) const –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator¶

Bases: FeaturesReporterCreator

creator for the HBondParameterFeatures class

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator, : pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator) → pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator¶: C++: protocols::antibody::AntibodyFeaturesCreator::operator=(const class protocols::antibody::AntibodyFeaturesCreator &) –> class protocols::antibody::AntibodyFeaturesCreator &

create_features_reporter(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator) → pyrosetta.rosetta.protocols.features.FeaturesReporter¶: C++: protocols::antibody::AntibodyFeaturesCreator::create_features_reporter() const –> class std::shared_ptr<class protocols::features::FeaturesReporter>

provide_xml_schema(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyFeaturesCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

type_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyFeaturesCreator) → str¶: C++: protocols::antibody::AntibodyFeaturesCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.antibody.AntibodyInfo¶

Bases: pybind11_object

This class is used to get all relevant information you would need when dealing with an antibody.

It mainly holds numbering information, but passes out a variety of Rosetta specific objects like movemaps, Loops, taskfactories, etc.: as well as other information such as CDR cluster type, camelid, H3 types, etc.

add_CDR_to_MoveMap(*args, **kwargs)¶

Overloaded function.

add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> None
add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, bb_only: bool) -> None
add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, bb_only: bool, include_nb_sc: bool) -> None
add_CDR_to_MoveMap(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, movemap: pyrosetta.rosetta.core.kinematics.MoveMap, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, bb_only: bool, include_nb_sc: bool, nb_dist: float) -> None

Add CDR flexibility to a movemap. Uses pose for numbering.

C++: protocols::antibody::AntibodyInfo::add_CDR_to_MoveMap(const class core::pose::Pose &, class std::shared_ptr<class core::kinematics::MoveMap>, const enum protocols::antibody::CDRNameEnum, const bool &, const bool &, const double &) const –> void

antigen_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶

return whether this pose has antigen or not

C++: protocols::antibody::AntibodyInfo::antigen_present() const –> bool

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, : pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyInfo¶: C++: protocols::antibody::AntibodyInfo::operator=(const class protocols::antibody::AntibodyInfo &) –> class protocols::antibody::AntibodyInfo &

clone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyInfo¶

Clone the pointer.

C++: protocols::antibody::AntibodyInfo::clone() const –> class std::shared_ptr<class protocols::antibody::AntibodyInfo>

get_AllCDRs_in_loopsop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.loops.Loops¶

return a LoopsOP object, initialized upon class construction.

C++: protocols::antibody::AntibodyInfo::get_AllCDRs_in_loopsop() const –> class std::shared_ptr<class protocols::loops::Loops>

get_AntibodyFrameworkInfo(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_utility_vector1_protocols_antibody_FrameWork_std_allocator_protocols_antibody_FrameWork_t¶

return the framework numbering information

C++: protocols::antibody::AntibodyInfo::get_AntibodyFrameworkInfo() const –> class utility::vector1<class utility::vector1<struct protocols::antibody::FrameWork, class std::allocator<struct protocols::antibody::FrameWork> >, class std::allocator<class utility::vector1<struct protocols::antibody::FrameWork, class std::allocator<struct protocols::antibody::FrameWork> > > >

get_CDRNameEnum_of_residue(*args, **kwargs)¶

Overloaded function.

get_CDRNameEnum_of_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> pyrosetta.rosetta.protocols.antibody.CDRNameEnum
get_CDRNameEnum_of_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, de_as_framework: bool) -> pyrosetta.rosetta.protocols.antibody.CDRNameEnum

Get the CDRNameEnum for region, if not in a CDR throw exception – CDR can be id’ed with the “get_region_of_residue” function

C++: protocols::antibody::AntibodyInfo::get_CDRNameEnum_of_residue(const class core::pose::Pose &, unsigned long, bool) const –> enum protocols::antibody::CDRNameEnum

get_CDR_chain(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → str¶: C++: protocols::antibody::AntibodyInfo::get_CDR_chain(const enum protocols::antibody::CDRNameEnum) const –> char

get_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → protocols::antibody::clusters::CDRCluster¶

get the cdr’s cluster identity and distance to cluster using it’s structure as a CDRCluster object.

See North, B., A. Lehmann, et al. (2011). JMB 406(2): 228-256.
Must use setup_CDR_clusters first.

If this AbInfo does not have all 6 chains, CDRClusterOP may be NULL if the CDR is not present to begin with.

C++: protocols::antibody::AntibodyInfo::get_CDR_cluster(const enum protocols::antibody::CDRNameEnum) const –> class std::shared_ptr<const class protocols::antibody::clusters::CDRCluster>

get_CDR_cluster_set(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → protocols::antibody::clusters::CDRClusterSet¶: C++: protocols::antibody::AntibodyInfo::get_CDR_cluster_set() const –> class std::shared_ptr<class protocols::antibody::clusters::CDRClusterSet>

get_CDR_end(*args, **kwargs)¶

Overloaded function.

get_CDR_end(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Return pose number of CDR end residue in the definition of the numbering scheme of transform.

C++: protocols::antibody::AntibodyInfo::get_CDR_end(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) const –> unsigned long

get_CDR_end(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> int

C++: protocols::antibody::AntibodyInfo::get_CDR_end(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum &) const –> unsigned long

get_CDR_end_PDB_num(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → int¶

Return PDB residue number of CDR end residue

C++: protocols::antibody::AntibodyInfo::get_CDR_end_PDB_num(const enum protocols::antibody::CDRNameEnum) const –> unsigned long

get_CDR_in_loopsop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.protocols.loops.Loops¶

return the loop of a certain loop type

C++: protocols::antibody::AntibodyInfo::get_CDR_in_loopsop(const enum protocols::antibody::CDRNameEnum) const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_length(*args, **kwargs)¶

Overloaded function.

get_CDR_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> int

get the length of the cdr upon construction of AntibodyInfo

Does not work for proto CDR4 (DE loop)

C++: protocols::antibody::AntibodyInfo::get_CDR_length(const enum protocols::antibody::CDRNameEnum) const –> unsigned long

get_CDR_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> int

On-the-fly CDR length.

C++: protocols::antibody::AntibodyInfo::get_CDR_length(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) const –> unsigned long

get_CDR_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> int

C++: protocols::antibody::AntibodyInfo::get_CDR_length(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum) const –> unsigned long

get_CDR_loop(*args, **kwargs)¶

Overloaded function.

get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> pyrosetta.rosetta.protocols.loops.Loop

return the loop of a certain loop type

C++: protocols::antibody::AntibodyInfo::get_CDR_loop(const enum protocols::antibody::CDRNameEnum) const –> class protocols::loops::Loop

get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loop
get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loop

return the loop of a certain loop type on the fly

C++: protocols::antibody::AntibodyInfo::get_CDR_loop(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, unsigned long) const –> class protocols::loops::Loop

get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> pyrosetta.rosetta.protocols.loops.Loop
get_CDR_loop(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loop

return the loop of a certain loop type in definitions of the numbering scheme transform.

C++: protocols::antibody::AntibodyInfo::get_CDR_loop(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum, unsigned long) const –> class protocols::loops::Loop

get_CDR_loops(*args, **kwargs)¶

Overloaded function.

get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.protocols.loops.Loops
get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loops

On-the-fly CDR LoopsOP

C++: protocols::antibody::AntibodyInfo::get_CDR_loops(const class core::pose::Pose &, unsigned long) const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.protocols.loops.Loops
get_CDR_loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, overhang: int) -> pyrosetta.rosetta.protocols.loops.Loops

C++: protocols::antibody::AntibodyInfo::get_CDR_loops(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) const –> class std::shared_ptr<class protocols::loops::Loops>

get_CDR_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → str¶: C++: protocols::antibody::AntibodyInfo::get_CDR_name(const enum protocols::antibody::CDRNameEnum) const –> std::string

get_CDR_name_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: str) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶: C++: protocols::antibody::AntibodyInfo::get_CDR_name_enum(const std::string &) const –> enum protocols::antibody::CDRNameEnum

get_CDR_sequence_with_stem(*args, **kwargs)¶

Overloaded function.

get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, left_stem: int) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, left_stem: int, right_stem: int) -> str

return the sequence of a particular CDR loop: Deprecated in favor of on the fly sequence.

C++: protocols::antibody::AntibodyInfo::get_CDR_sequence_with_stem(const enum protocols::antibody::CDRNameEnum, unsigned long, unsigned long) const –> std::string

get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, left_stem: int) -> str
get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, left_stem: int, right_stem: int) -> str

On-The-Fly CDR sequence

C++: protocols::antibody::AntibodyInfo::get_CDR_sequence_with_stem(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, unsigned long, unsigned long) const –> std::string

get_CDR_sequence_with_stem(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, left_stem: int, right_stem: int, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> str

On-The-Fly CDR sequence

C++: protocols::antibody::AntibodyInfo::get_CDR_sequence_with_stem(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, unsigned long, unsigned long, const enum protocols::antibody::CDRDefinitionEnum &) const –> std::string

get_CDR_start(*args, **kwargs)¶

Overloaded function.

get_CDR_start(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> int

Return pose number of CDR start residue

C++: protocols::antibody::AntibodyInfo::get_CDR_start(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) const –> unsigned long

get_CDR_start(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, transform: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) -> int

C++: protocols::antibody::AntibodyInfo::get_CDR_start(const enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &, const enum protocols::antibody::CDRDefinitionEnum &) const –> unsigned long

get_CDR_start_PDB_num(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → int¶

Return PDB residue number of CDR start residue

C++: protocols::antibody::AntibodyInfo::get_CDR_start_PDB_num(const enum protocols::antibody::CDRNameEnum) const –> unsigned long

get_FoldTree_AllCDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_AllCDRs(const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::FoldTree>

get_FoldTree_AllCDRs_LHDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_AllCDRs_LHDock(const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::FoldTree>

get_FoldTree_LA_H(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_LA_H(const class core::pose::Pose &) const –> class core::kinematics::FoldTree

get_FoldTree_LH_A(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶

SnugDock foldtrees

C++: protocols::antibody::AntibodyInfo::get_FoldTree_LH_A(const class core::pose::Pose &) const –> class core::kinematics::FoldTree

get_FoldTree_L_HA(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::get_FoldTree_L_HA(const class core::pose::Pose &) const –> class core::kinematics::FoldTree

get_H3_kink_type(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum¶

get H3 cterminal kink/extended conformation (predicted by constructor)

C++: protocols::antibody::AntibodyInfo::get_H3_kink_type() const –> enum protocols::antibody::H3BaseTypeEnum

get_H3_kink_type_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶: C++: protocols::antibody::AntibodyInfo::get_H3_kink_type_name() const –> std::string

get_MoveMap_for_AllCDRsSideChains_and_H3backbone(*args, **kwargs)¶

Overloaded function.

get_MoveMap_for_AllCDRsSideChains_and_H3backbone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_AllCDRsSideChains_and_H3backbone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_AllCDRsSideChains_and_H3backbone(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, include_nb_sc: bool, nb_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::AntibodyInfo::get_MoveMap_for_AllCDRsSideChains_and_H3backbone(const class core::pose::Pose &, const bool &, const double &) const –> class core::kinematics::MoveMap

get_MoveMap_for_Loops(*args, **kwargs)¶

Overloaded function.

get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_Loops(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool, nb_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap

TODO: this should be a standard utility for loops?

get a movemap for loops.

C++: protocols::antibody::AntibodyInfo::get_MoveMap_for_Loops(const class core::pose::Pose &, const class protocols::loops::Loops &, const bool &, const bool &, const double &) const –> class core::kinematics::MoveMap

get_MoveMap_for_LoopsandDock(*args, **kwargs)¶

Overloaded function.

get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_MoveMap_for_LoopsandDock(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, the_loops: pyrosetta.rosetta.protocols.loops.Loops, bb_only: bool, include_nb_sc: bool, nb_dist: float) -> pyrosetta.rosetta.core.kinematics.MoveMap

get a movemap for loops and set the first jump be true

C++: protocols::antibody::AntibodyInfo::get_MoveMap_for_LoopsandDock(const class core::pose::Pose &, const class protocols::loops::Loops &, const bool &, const bool &, const double &) const –> class core::kinematics::MoveMap

get_PackingAngleResidues(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

get residues used to calculate VL/VH packing angle

C++: protocols::antibody::AntibodyInfo::get_PackingAngleResidues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_TaskFactory_AllCDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.TaskFactory¶

TaskFactory

C++: protocols::antibody::AntibodyInfo::get_TaskFactory_AllCDRs(class core::pose::Pose &) const –> class std::shared_ptr<class core::pack::task::TaskFactory>

get_TaskFactory_OneCDR(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.core.pack.task.TaskFactory¶: C++: protocols::antibody::AntibodyInfo::get_TaskFactory_OneCDR(class core::pose::Pose &, const enum protocols::antibody::CDRNameEnum) const –> class std::shared_ptr<class core::pack::task::TaskFactory>

get_all_cdrs(*args, **kwargs)¶

Overloaded function.

get_all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum
get_all_cdrs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_proto_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

Get a vector of all CDRs. Easy to iterate on.

C++: protocols::antibody::AntibodyInfo::get_all_cdrs(bool) const –> const class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> > &

get_all_cdrs_present(*args, **kwargs)¶

Overloaded function.

get_all_cdrs_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum
get_all_cdrs_present(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_proto_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

Get a vector of all the CDRs in this antibody. Easy to iterate on.

C++: protocols::antibody::AntibodyInfo::get_all_cdrs_present(bool) const –> const class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> > &

get_antibody_chain_ids(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::antibody::AntibodyInfo::get_antibody_chain_ids(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_antibody_chain_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

Returns H or LH depeding on camelid.

C++: protocols::antibody::AntibodyInfo::get_antibody_chain_string() const –> std::string

get_antibody_chains(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_char¶: C++: protocols::antibody::AntibodyInfo::get_antibody_chains() const –> class utility::vector1<char, class std::allocator<char> >

get_antibody_enum_manager(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyEnumManager¶

Get a const OP to the antibody enum manager

C++: protocols::antibody::AntibodyInfo::get_antibody_enum_manager() const –> class std::shared_ptr<const class protocols::antibody::AntibodyEnumManager>

get_antibody_numbering_info(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.AntibodyNumbering¶

Get the full antibody numbering struct for use in anything.

C++: protocols::antibody::AntibodyInfo::get_antibody_numbering_info() const –> const struct protocols::antibody::AntibodyNumbering &

get_antibody_sequence(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

return the antibody sequence of LH or just H for camelid

C++: protocols::antibody::AntibodyInfo::get_antibody_sequence() const –> std::string

get_antigen_chain_ids(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::antibody::AntibodyInfo::get_antigen_chain_ids(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_antigen_chain_string(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

Return the antigen chains as a string

C++: protocols::antibody::AntibodyInfo::get_antigen_chain_string() const –> std::string

get_antigen_chains(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.utility.vector1_char¶

gets all non-LH chains. Empty vector if no antigen present.

C++: protocols::antibody::AntibodyInfo::get_antigen_chains() const –> class utility::vector1<char, class std::allocator<char> >

get_cdr_cluster_enum_manager(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → protocols::antibody::clusters::CDRClusterEnumManager¶

Get a const OP to the cluster enum manager

C++: protocols::antibody::AntibodyInfo::get_cdr_cluster_enum_manager() const –> class std::shared_ptr<const class protocols::antibody::clusters::CDRClusterEnumManager>

get_cdr_enum_for_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶: C++: protocols::antibody::AntibodyInfo::get_cdr_enum_for_cluster(const enum protocols::antibody::clusters::CDRClusterEnum) const –> enum protocols::antibody::CDRNameEnum

get_cluster_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: str) → pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum¶: C++: protocols::antibody::AntibodyInfo::get_cluster_enum(const std::string &) const –> enum protocols::antibody::clusters::CDRClusterEnum

get_cluster_length(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → int¶: C++: protocols::antibody::AntibodyInfo::get_cluster_length(const enum protocols::antibody::clusters::CDRClusterEnum) const –> unsigned long

get_cluster_name(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → str¶: C++: protocols::antibody::AntibodyInfo::get_cluster_name(const enum protocols::antibody::clusters::CDRClusterEnum) const –> std::string

get_current_AntibodyNumberingScheme(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

: get the current numbering scheme being used

C++: protocols::antibody::AntibodyInfo::get_current_AntibodyNumberingScheme() const –> std::string

get_current_CDRDefinition(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶: C++: protocols::antibody::AntibodyInfo::get_current_CDRDefinition() const –> std::string

get_landmark_resnum(*args, **kwargs)¶

Overloaded function.

get_landmark_resnum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, chain: str, pdb_resnum: int) -> int
get_landmark_resnum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, chain: str, pdb_resnum: int, insertion_code: str) -> int
get_landmark_resnum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, chain: str, pdb_resnum: int, insertion_code: str, fail_on_missing_resnum: bool) -> int

Used to get a residue number of a particular place in the framework or conserved residue in the CDR.

Use this instead of PDBInfo!!

If the current numbering scheme is not ‘scheme’, will return the equivalent position of the current numbering scheme using the transform scheme file in the database. Should not be used for residues within CDRs since numbering schemes vary greatly in their within cdr alignments and numbering. Use get_CDR_start/end/loop functions with relative positions for this purpose. Returns 0 if residue is not found in pose

C++: protocols::antibody::AntibodyInfo::get_landmark_resnum(const class core::pose::Pose &, const enum protocols::antibody::AntibodyNumberingSchemeEnum, const char, const unsigned long, const char, bool) const –> unsigned long

get_light_chain_type(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str¶

Return if antibody is lambda, kappa or unknown. Type set via cmd-line option for now

C++: protocols::antibody::AntibodyInfo::get_light_chain_type() const –> std::string

get_light_chain_type_enum(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum¶

Return if antibody is lambda, kappa or unknown. Type set via cmd-line option for now

C++: protocols::antibody::AntibodyInfo::get_light_chain_type_enum() const –> enum protocols::antibody::LightChainTypeEnum

get_region_of_residue(*args, **kwargs)¶

Overloaded function.

get_region_of_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum
get_region_of_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, de_as_framework: bool) -> pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum

Get the region of the resnum - aka - antigen_region, cdr_region, or framework_region: By default, count the DE region (CDR4) as framework.

C++: protocols::antibody::AntibodyInfo::get_region_of_residue(const class core::pose::Pose &, unsigned long, bool) const –> enum protocols::antibody::AntibodyRegionEnum

get_total_num_CDRs(*args, **kwargs)¶

Overloaded function.

get_total_num_CDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> int
get_total_num_CDRs(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, include_proto_cdr4: bool) -> int

return num of cdr loops, 3 (nanobody) or 6 (regular antibody): Do not use for enum-based for loop if including cdr4. Use get_all_cdrs_present instead!

C++: protocols::antibody::AntibodyInfo::get_total_num_CDRs(bool) const –> unsigned long

has_CDR(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → bool¶

Does the antibody have this CDR?

See also:: is_camelid()) get_total_num_CDRs())

C++: protocols::antibody::AntibodyInfo::has_CDR(const enum protocols::antibody::CDRNameEnum) const –> bool

has_cluster_for_cdr(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr_name: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → bool¶

Check to make sure AbInfo has a cluster object for this CDR. In that all 6 CDRs not nessessarily present for each antibody.

C++: protocols::antibody::AntibodyInfo::has_cluster_for_cdr(const enum protocols::antibody::CDRNameEnum) const –> bool

is_camelid(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶

return this antibody is camelid or not

C++: protocols::antibody::AntibodyInfo::is_camelid() const –> bool

kink_anion_atoms(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t¶

return side chain anion atoms (typically Asp/Glu oxygens) in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_anion_atoms(const class core::pose::Pose &) const –> class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >

kink_anion_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the kink ‘anion’ (typically Asp/Glu) residue in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_anion_residue(const class core::pose::Pose &) const –> unsigned long

kink_begin(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the first residue of the H3 kink

C++: protocols::antibody::AntibodyInfo::kink_begin(const class core::pose::Pose &) const –> unsigned long

kink_cation_atoms(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.vector_numeric_xyzVector_double_t¶

return side chain cation atoms (typically Lys/His nitrogens) in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_cation_atoms(const class core::pose::Pose &) const –> class std::vector<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >

kink_cation_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the kink ‘cation’ (typically Arg/Lys) residue in the kink bulge HBond

C++: protocols::antibody::AntibodyInfo::kink_cation_residue(const class core::pose::Pose &) const –> unsigned long

kink_end(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the last residue of the H3 kink

C++: protocols::antibody::AntibodyInfo::kink_end(const class core::pose::Pose &) const –> unsigned long

kink_trp(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶

return pose residue number of the last residue of the H3 kink

C++: protocols::antibody::AntibodyInfo::kink_trp(const class core::pose::Pose &) const –> unsigned long

qq_heavy_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::antibody::AntibodyInfo::qq_heavy_residue(const class core::pose::Pose &) const –> unsigned long

qq_light_residue(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → int¶: C++: protocols::antibody::AntibodyInfo::qq_light_residue(const class core::pose::Pose &) const –> unsigned long

set_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, cluster: protocols::antibody::clusters::CDRCluster) → None¶

Manually set the CDR cluster for a particular CDR

C++: protocols::antibody::AntibodyInfo::set_CDR_cluster(enum protocols::antibody::CDRNameEnum, class std::shared_ptr<const class protocols::antibody::clusters::CDRCluster>) –> void

set_light_chain_type(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, light_chain: pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum) → None¶

Set the light chain type via enum

C++: protocols::antibody::AntibodyInfo::set_light_chain_type(enum protocols::antibody::LightChainTypeEnum) –> void

setup_CDR_cluster(*args, **kwargs)¶

Overloaded function.

setup_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> None
setup_CDR_cluster(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, attempt_set_from_pose: bool) -> None

setup the clustering information for a particular CDR.: Optionally, attempt to set the CDR cluster from the Pose data cache if any data is there.

C++: protocols::antibody::AntibodyInfo::setup_CDR_cluster(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum, bool) –> void

setup_CDR_clusters(*args, **kwargs)¶

Overloaded function.

setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None
setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, attempt_set_from_pose: bool) -> None

setup the clustering information for each CDR to totalCDRLoops: Optionally, attempt to set the CDR cluster from the Pose data cache if any data is there.

C++: protocols::antibody::AntibodyInfo::setup_CDR_clusters(const class core::pose::Pose &, bool) –> void

setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> None
setup_CDR_clusters(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, attempt_set_from_pose: bool) -> None

setup the clustering information for each CDR according to boolean vector.: Optionally, attempt to set the CDR cluster from the Pose data cache if any data is there.

C++: protocols::antibody::AntibodyInfo::setup_CDR_clusters(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, bool) –> void

setup_simple_fold_tree(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, jumppoint1: int, cutpoint: int, jumppoint2: int, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::AntibodyInfo::setup_simple_fold_tree(const unsigned long &, const unsigned long &, const unsigned long &, const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::FoldTree>

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
show(self: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, out: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::AntibodyInfo::show(std::ostream &) const –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, : pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol) → pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol¶: C++: protocols::antibody::AntibodyModelerProtocol::operator=(const class protocols::antibody::AntibodyModelerProtocol &) –> class protocols::antibody::AntibodyModelerProtocol &

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.antibody.AntibodyModelerProtocol) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::AntibodyModelerProtocol::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>

display_constraint_residues(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::display_constraint_residues(class core::pose::Pose &) –> 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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.AntibodyModelerProtocol) → str¶: C++: protocols::antibody::AntibodyModelerProtocol::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static register_options() → None¶

Associates relevant options with the AntibodyModeler class

C++: protocols::antibody::AntibodyModelerProtocol::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_BenchMark(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_BenchMark(bool) –> void

set_ModelH3(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_ModelH3(bool) –> void

set_SnugFit(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_SnugFit(bool) –> void

set_auto_h3_constraint(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_auto_h3_constraint(const bool) –> void

set_constrain_vlvh_qq(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_constrain_vlvh_qq(const bool) –> void

set_cst_weight(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, cst_weight: float) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_cst_weight(const double) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol) → None¶

Assigns default values to primitive members

C++: protocols::antibody::AntibodyModelerProtocol::set_default() –> void

set_extend_h3_before_modeling(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_extend_h3_before_modeling(bool) –> void

set_h3_loop_csts_hr(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_h3_loop_csts_hr(const bool) –> void

set_h3_loop_csts_lr(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_h3_loop_csts_lr(const bool) –> 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_middle_pack_min(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, middle_pack_min: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_middle_pack_min(bool) –> 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_packonly_after_graft(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_packonly_after_graft(bool) –> void

set_refine_h3(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_refine_h3(bool) –> void

set_rt_min(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_rt_min(bool) –> void

set_sc_min(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, setting: bool) → None¶: C++: protocols::antibody::AntibodyModelerProtocol::set_sc_min(bool) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol) -> None
show(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol, out: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::AntibodyModelerProtocol::show(std::ostream &) const –> void

sync_objects_with_flags(self: pyrosetta.rosetta.protocols.antibody.AntibodyModelerProtocol) → None¶

Instantiates non-primitive members based on the value of the primitive members

C++: protocols::antibody::AntibodyModelerProtocol::sync_objects_with_flags() –> 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.AntibodyNumbering¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumbering, : pyrosetta.rosetta.protocols.antibody.AntibodyNumbering) → pyrosetta.rosetta.protocols.antibody.AntibodyNumbering¶: C++: protocols::antibody::AntibodyNumbering::operator=(const struct protocols::antibody::AntibodyNumbering &) –> struct protocols::antibody::AntibodyNumbering &

property cdr_definition¶

property cdr_definition_transform¶

property cdr_numbering¶

property numbering_scheme¶

property numbering_scheme_transform¶

class pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover¶

Bases: Mover

Converts numbering schemes of an antibody, independant of AntibodyInfo.: By default, works on a SINGLE antibody FAB with chains L and H, as in the rest of Rosetta.

Usable Numbering Schemes:

Chothia_Scheme Enhanced_Chothia_Scheme AHO_Scheme Kabat_Scheme IMGT_Scheme

apply(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::AntibodyNumberingConverterMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, : pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover¶: C++: protocols::antibody::AntibodyNumberingConverterMover::operator=(const class protocols::antibody::AntibodyNumberingConverterMover &) –> class protocols::antibody::AntibodyNumberingConverterMover &

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.antibody.AntibodyNumberingConverterMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::antibody::AntibodyNumberingConverterMover::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>

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

required in the context of the parser/scripting scheme

C++: protocols::antibody::AntibodyNumberingConverterMover::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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.AntibodyNumberingConverterMover) → str¶: C++: protocols::antibody::AntibodyNumberingConverterMover::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_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

static mover_name() → str¶: C++: protocols::antibody::AntibodyNumberingConverterMover::mover_name() –> std::string

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::antibody::AntibodyNumberingConverterMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide the citation.

C++: protocols::antibody::AntibodyNumberingConverterMover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyNumberingConverterMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static 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¶: 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 std::string &) –> void

set_from_scheme(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, from: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → None¶

Set the current numbering scheme of the antibody.

C++: protocols::antibody::AntibodyNumberingConverterMover::set_from_scheme(const enum protocols::antibody::AntibodyNumberingSchemeEnum) –> 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_scheme_conversion(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, from: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, to: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → None¶

Set the scheme to convert the pose into.

C++: protocols::antibody::AntibodyNumberingConverterMover::set_scheme_conversion(const enum protocols::antibody::AntibodyNumberingSchemeEnum, const enum protocols::antibody::AntibodyNumberingSchemeEnum) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover) -> None
show(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMover, output: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::AntibodyNumberingConverterMover::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator¶

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator, : pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator¶: C++: protocols::antibody::AntibodyNumberingConverterMoverCreator::operator=(const class protocols::antibody::AntibodyNumberingConverterMoverCreator &) –> class protocols::antibody::AntibodyNumberingConverterMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::AntibodyNumberingConverterMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator) → str¶: C++: protocols::antibody::AntibodyNumberingConverterMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingConverterMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::antibody::AntibodyNumberingConverterMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser¶

Bases: pybind11_object

Class responsible for reading database Numbering Scheme definitions and their transforms from the database.

assign(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser, : pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser¶: C++: protocols::antibody::AntibodyNumberingParser::operator=(const class protocols::antibody::AntibodyNumberingParser &) –> class protocols::antibody::AntibodyNumberingParser &

get_antibody_numbering(self: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingParser, numbering_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, cdr_definition: pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum) → pyrosetta.rosetta.protocols.antibody.AntibodyNumbering¶

Read numbering file and return AntibodyNumbering structure

C++: protocols::antibody::AntibodyNumberingParser::get_antibody_numbering(const enum protocols::antibody::AntibodyNumberingSchemeEnum, const enum protocols::antibody::CDRDefinitionEnum) –> struct protocols::antibody::AntibodyNumbering

class pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum¶

Bases: pybind11_object

Members:

Chothia_Scheme

Kabat_Scheme

Enhanced_Chothia_Scheme

IMGT_Scheme

AHO_Scheme

AntibodyNumberingSchemeEnum_start

AntibodyNumberingSchemeEnum_total

NONE

AHO_Scheme = <AntibodyNumberingSchemeEnum.AHO_Scheme: 5>¶

AntibodyNumberingSchemeEnum_start = <AntibodyNumberingSchemeEnum.Chothia_Scheme: 1>¶

AntibodyNumberingSchemeEnum_total = <AntibodyNumberingSchemeEnum.AHO_Scheme: 5>¶

Chothia_Scheme = <AntibodyNumberingSchemeEnum.Chothia_Scheme: 1>¶

Enhanced_Chothia_Scheme = <AntibodyNumberingSchemeEnum.Enhanced_Chothia_Scheme: 3>¶

IMGT_Scheme = <AntibodyNumberingSchemeEnum.IMGT_Scheme: 4>¶

Kabat_Scheme = <AntibodyNumberingSchemeEnum.Kabat_Scheme: 2>¶

NONE = <AntibodyNumberingSchemeEnum.NONE: 6>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum¶

Bases: pybind11_object

Members:

antigen_region

cdr_region

framework_region

AntibodyRegionEnum_start

AntibodyRegionEnum_total

unknown_ab_region

AntibodyRegionEnum_start = <AntibodyRegionEnum.antigen_region: 1>¶

AntibodyRegionEnum_total = <AntibodyRegionEnum.framework_region: 3>¶

antigen_region = <AntibodyRegionEnum.antigen_region: 1>¶

cdr_region = <AntibodyRegionEnum.cdr_region: 2>¶

framework_region = <AntibodyRegionEnum.framework_region: 3>¶

property name¶

unknown_ab_region = <AntibodyRegionEnum.unknown_ab_region: 4>¶

property value¶

class pyrosetta.rosetta.protocols.antibody.CDRDBPose¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.CDRDBPose, : pyrosetta.rosetta.protocols.antibody.CDRDBPose) → pyrosetta.rosetta.protocols.antibody.CDRDBPose¶: C++: protocols::antibody::CDRDBPose::operator=(const struct protocols::antibody::CDRDBPose &) –> struct protocols::antibody::CDRDBPose &

property cluster¶

property distance¶

property normalized_distance¶

property pdb¶

property pose¶

property resolution¶

property struct_id¶

property structure_length¶

class pyrosetta.rosetta.protocols.antibody.CDRDBSequence¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.CDRDBSequence, : pyrosetta.rosetta.protocols.antibody.CDRDBSequence) → pyrosetta.rosetta.protocols.antibody.CDRDBSequence¶: C++: protocols::antibody::CDRDBSequence::operator=(const struct protocols::antibody::CDRDBSequence &) –> struct protocols::antibody::CDRDBSequence &

property cluster¶

property distance¶

property normalized_distance¶

property pdb¶

property resolution¶

property sequence¶

class pyrosetta.rosetta.protocols.antibody.CDRDefinitionEnum¶

Bases: pybind11_object

Members:

Chothia

Aroop

Kabat

Martin

North

CDRDefinitionEnum_start

CDRDefinitionEnum_total

Aroop = <CDRDefinitionEnum.Aroop: 2>¶

CDRDefinitionEnum_start = <CDRDefinitionEnum.Chothia: 1>¶

CDRDefinitionEnum_total = <CDRDefinitionEnum.North: 5>¶

Chothia = <CDRDefinitionEnum.Chothia: 1>¶

Kabat = <CDRDefinitionEnum.Kabat: 3>¶

Martin = <CDRDefinitionEnum.Martin: 4>¶

North = <CDRDefinitionEnum.North: 5>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.antibody.CDRLandmarkEnum¶

Bases: pybind11_object

Main enumerator for AntibodyNumbering.

Members:

cdr_start

cdr_end

CDRLandmarkEnum_total

CDRLandmarkEnum_total = <CDRLandmarkEnum.cdr_end: 2>¶

cdr_end = <CDRLandmarkEnum.cdr_end: 2>¶

cdr_start = <CDRLandmarkEnum.cdr_start: 1>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶

Bases: pybind11_object

Members:

h1

h2

h3

l1

l2

l3

proto_h4

proto_l4

start_cdr_loop

H_chain_last_loop

L_chain_last_loop

camelid_last_loop

num_cdr_loops

CDRNameEnum_start

CDRNameEnum_total

CDRNameEnum_proto_start

CDRNameEnum_proto_total

l4

h4

L1

L2

L3

H1

H2

H3

L4

H4

CDRNameEnum_proto_start = <CDRNameEnum.proto_h4: 7>¶

CDRNameEnum_proto_total = <CDRNameEnum.proto_l4: 8>¶

CDRNameEnum_start = <CDRNameEnum.h1: 1>¶

CDRNameEnum_total = <CDRNameEnum.l3: 6>¶

H1 = <CDRNameEnum.h1: 1>¶

H2 = <CDRNameEnum.h2: 2>¶

H3 = <CDRNameEnum.h3: 3>¶

H4 = <CDRNameEnum.proto_h4: 7>¶

H_chain_last_loop = <CDRNameEnum.h3: 3>¶

L1 = <CDRNameEnum.l1: 4>¶

L2 = <CDRNameEnum.l2: 5>¶

L3 = <CDRNameEnum.l3: 6>¶

L4 = <CDRNameEnum.proto_l4: 8>¶

L_chain_last_loop = <CDRNameEnum.l3: 6>¶

camelid_last_loop = <CDRNameEnum.h3: 3>¶

h1 = <CDRNameEnum.h1: 1>¶

h2 = <CDRNameEnum.h2: 2>¶

h3 = <CDRNameEnum.h3: 3>¶

h4 = <CDRNameEnum.proto_h4: 7>¶

l1 = <CDRNameEnum.l1: 4>¶

l2 = <CDRNameEnum.l2: 5>¶

l3 = <CDRNameEnum.l3: 6>¶

l4 = <CDRNameEnum.proto_l4: 8>¶

property name¶

num_cdr_loops = <CDRNameEnum.l3: 6>¶

proto_h4 = <CDRNameEnum.proto_h4: 7>¶

proto_l4 = <CDRNameEnum.proto_l4: 8>¶

start_cdr_loop = <CDRNameEnum.h1: 1>¶

property value¶

class pyrosetta.rosetta.protocols.antibody.CDRSetOptions¶

Bases: pybind11_object

Class that holds instructions for a single CDR for loading from the antibody database. Default is instructions to load all CDRs from the database

assign(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, : pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → pyrosetta.rosetta.protocols.antibody.CDRSetOptions¶: C++: protocols::antibody::CDRSetOptions::operator=(const class protocols::antibody::CDRSetOptions &) –> class protocols::antibody::CDRSetOptions &

cdr(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum¶: C++: protocols::antibody::CDRSetOptions::cdr() const –> enum protocols::antibody::CDRNameEnum

clone(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → pyrosetta.rosetta.protocols.antibody.CDRSetOptions¶: C++: protocols::antibody::CDRSetOptions::clone() const –> class std::shared_ptr<class protocols::antibody::CDRSetOptions>

cluster_sampling_cutoff(*args, **kwargs)¶

Overloaded function.

cluster_sampling_cutoff(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, cutoff: int) -> None

Set a sampling cutoff. Use zero for no cutoff as default.

C++: protocols::antibody::CDRSetOptions::cluster_sampling_cutoff(unsigned long) –> void

cluster_sampling_cutoff(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> int

C++: protocols::antibody::CDRSetOptions::cluster_sampling_cutoff() const –> unsigned long

exclude_clusters(*args, **kwargs)¶

Overloaded function.

exclude_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum) -> None

/////////// Clusters /////////////////

C++: protocols::antibody::CDRSetOptions::exclude_clusters(class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >) –> void

exclude_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum

C++: protocols::antibody::CDRSetOptions::exclude_clusters() const –> class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >

exclude_clusters_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_clusters_add(enum protocols::antibody::clusters::CDRClusterEnum) –> void

exclude_clusters_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_clusters_clear() –> void

exclude_germlines(*args, **kwargs)¶

Overloaded function.

exclude_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.utility.vector1_std_string) -> None

//////// Germlines ////////////////////

C++: protocols::antibody::CDRSetOptions::exclude_germlines(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

exclude_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::exclude_germlines() const –> class utility::vector1<std::string, class std::allocator<std::string > >

exclude_germlines_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: str) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_germlines_add(std::string) –> void

exclude_germlines_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_germlines_clear() –> void

exclude_pdbs(*args, **kwargs)¶

Overloaded function.

exclude_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude_pdbids: pyrosetta.rosetta.utility.vector1_std_string) -> None

/////////// PDBIds ///////////////////

C++: protocols::antibody::CDRSetOptions::exclude_pdbs(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

exclude_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::exclude_pdbs() const –> class utility::vector1<std::string, class std::allocator<std::string > >

exclude_pdbs_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, pdbid: str) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_pdbs_add(std::string) –> void

exclude_pdbs_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_pdbs_clear() –> void

exclude_species(*args, **kwargs)¶

Overloaded function.

exclude_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: pyrosetta.rosetta.utility.vector1_std_string) -> None

////////// Species ////////////////////

C++: protocols::antibody::CDRSetOptions::exclude_species(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

exclude_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::exclude_species() const –> class utility::vector1<std::string, class std::allocator<std::string > >

exclude_species_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, exclude: str) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_species_add(std::string) –> void

exclude_species_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::exclude_species_clear() –> void

include_only_center_clusters(*args, **kwargs)¶

Overloaded function.

include_only_center_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, centers_only: bool) -> None

Do we only include the center members of the clusters in the CDRSet?

C++: protocols::antibody::CDRSetOptions::include_only_center_clusters(bool) –> void

include_only_center_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> bool

C++: protocols::antibody::CDRSetOptions::include_only_center_clusters() const –> bool

include_only_clusters(*args, **kwargs)¶

Overloaded function.

include_only_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum) -> None

C++: protocols::antibody::CDRSetOptions::include_only_clusters(class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >) –> void

include_only_clusters(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum

C++: protocols::antibody::CDRSetOptions::include_only_clusters() const –> class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >

include_only_clusters_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_clusters_add(enum protocols::antibody::clusters::CDRClusterEnum) –> void

include_only_clusters_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_clusters_clear() –> void

include_only_current_cluster(*args, **kwargs)¶

Overloaded function.

include_only_current_cluster(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, only_current_cluster: bool) -> None

If antibody CDRs are loaded in relation to the current PDB in whatever algorithm or app is using this,: Should we only pull clusters of the same type as this PDB?

May or may not be used. In AntibodyGraftDesign, this is used.

C++: protocols::antibody::CDRSetOptions::include_only_current_cluster(bool) –> void

include_only_current_cluster(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> bool

C++: protocols::antibody::CDRSetOptions::include_only_current_cluster() const –> bool

include_only_germlines(*args, **kwargs)¶

Overloaded function.

include_only_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::antibody::CDRSetOptions::include_only_germlines(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

include_only_germlines(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::include_only_germlines() const –> class utility::vector1<std::string, class std::allocator<std::string > >

include_only_germlines_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: str) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_germlines_add(std::string) –> void

include_only_germlines_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_germlines_clear() –> void

include_only_pdbs(*args, **kwargs)¶

Overloaded function.

include_only_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_pdbids: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::antibody::CDRSetOptions::include_only_pdbs(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

include_only_pdbs(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::include_only_pdbs() const –> class utility::vector1<std::string, class std::allocator<std::string > >

include_only_pdbs_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, pdbid: str) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_pdbs_add(std::string) –> void

include_only_pdbs_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_pdbs_clear() –> void

include_only_species(*args, **kwargs)¶

Overloaded function.

include_only_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::antibody::CDRSetOptions::include_only_species(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

include_only_species(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::CDRSetOptions::include_only_species() const –> class utility::vector1<std::string, class std::allocator<std::string > >

include_only_species_add(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, include_only: str) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_species_add(std::string) –> void

include_only_species_clear(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::include_only_species_clear() –> void

length_type(*args, **kwargs)¶

Overloaded function.

length_type(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, type: int, setting: bool) -> None

Set to only sample with clusters of the given type for this CDR.

C++: protocols::antibody::CDRSetOptions::length_type(const unsigned long, const bool) –> void

length_type(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> pyrosetta.rosetta.utility.vector1_bool

C++: protocols::antibody::CDRSetOptions::length_type() const –> class utility::vector1<bool, class std::allocator<bool> >

load(*args, **kwargs)¶

Overloaded function.

load(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, load: bool) -> None

C++: protocols::antibody::CDRSetOptions::load(bool) –> void

load(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> bool

C++: protocols::antibody::CDRSetOptions::load() const –> bool

max_length(*args, **kwargs)¶

Overloaded function.

max_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, length: int) -> None

set the maximum cdr length to sample. Nothing longer then this will be used. Useful for H3.

C++: protocols::antibody::CDRSetOptions::max_length(unsigned long) –> void

max_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> int

C++: protocols::antibody::CDRSetOptions::max_length() const –> unsigned long

min_length(*args, **kwargs)¶

Overloaded function.

min_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, length: int) -> None

set the minimum cdr length to sample. Nothing shorter then this will be used during graft.

C++: protocols::antibody::CDRSetOptions::min_length(unsigned long) –> void

min_length(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) -> int

C++: protocols::antibody::CDRSetOptions::min_length() const –> unsigned long

set_cdr(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None¶

/// General settings //////////////

C++: protocols::antibody::CDRSetOptions::set_cdr(enum protocols::antibody::CDRNameEnum) –> void

set_defaults(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptions) → None¶: C++: protocols::antibody::CDRSetOptions::set_defaults() –> void

class pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser¶

Bases: pybind11_object

Parses CDRSetOptions for a single CDR at a time from a simple instruction file

assign(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, : pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser) → pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser¶: C++: protocols::antibody::CDRSetOptionsParser::operator=(const class protocols::antibody::CDRSetOptionsParser &) –> class protocols::antibody::CDRSetOptionsParser &

clone(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser) → pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser¶: C++: protocols::antibody::CDRSetOptionsParser::clone() const –> class std::shared_ptr<class protocols::antibody::CDRSetOptionsParser>

parse_default_and_user_options(*args, **kwargs)¶

Overloaded function.

parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.CDRSetOptions

Parse default instructions (mainly used for AbDesign) then parse user file

C++: protocols::antibody::CDRSetOptionsParser::parse_default_and_user_options(enum protocols::antibody::CDRNameEnum, const std::string &) –> class std::shared_ptr<class protocols::antibody::CDRSetOptions>

parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

C++: protocols::antibody::CDRSetOptionsParser::parse_default_and_user_options(const std::string &) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >

parse_options(*args, **kwargs)¶

Overloaded function.

parse_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.CDRSetOptions

C++: protocols::antibody::CDRSetOptionsParser::parse_options(enum protocols::antibody::CDRNameEnum, const std::string &) –> class std::shared_ptr<class protocols::antibody::CDRSetOptions>

parse_options(self: pyrosetta.rosetta.protocols.antibody.CDRSetOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

//////////Parse Options for all CDRs////////////////

C++: protocols::antibody::CDRSetOptionsParser::parse_options(const std::string &) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >

pyrosetta.rosetta.protocols.antibody.CDR_H3_cter_filter(pose_in: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶: C++: protocols::antibody::CDR_H3_cter_filter(const class core::pose::Pose &, class std::shared_ptr<class protocols::antibody::AntibodyInfo>) –> bool

pyrosetta.rosetta.protocols.antibody.CDR_H3_filter_legacy_code_with_old_rule(pose_in: pyrosetta.rosetta.core.pose.Pose, input_loop: pyrosetta.rosetta.protocols.loops.Loop, is_camelid: bool) → bool¶: C++: protocols::antibody::CDR_H3_filter_legacy_code_with_old_rule(const class core::pose::Pose &, class protocols::loops::Loop &, bool) –> bool

class pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::CDRsMinPackMin::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, : pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin) → pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin¶: C++: protocols::antibody::CDRsMinPackMin::operator=(const class protocols::antibody::CDRsMinPackMin &) –> class protocols::antibody::CDRsMinPackMin &

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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.CDRsMinPackMin) → str¶: C++: protocols::antibody::CDRsMinPackMin::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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_alter_foldtree(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, setting: bool) → None¶: C++: protocols::antibody::CDRsMinPackMin::set_alter_foldtree(bool) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> 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_move_map(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶: C++: protocols::antibody::CDRsMinPackMin::set_move_map(class std::shared_ptr<const class core::kinematics::MoveMap>) –> 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_rt_min(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, rtmin: bool) → None¶: C++: protocols::antibody::CDRsMinPackMin::set_rt_min(bool) –> void

set_sc_min(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, scmin: bool) → None¶: C++: protocols::antibody::CDRsMinPackMin::set_sc_min(bool) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::CDRsMinPackMin::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

set_turnoff_minimization(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, setting: bool) → None¶: C++: protocols::antibody::CDRsMinPackMin::set_turnoff_minimization(bool) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin) -> None
show(self: pyrosetta.rosetta.protocols.antibody.CDRsMinPackMin, out: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::CDRsMinPackMin::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop¶

Bases: Mover

Closes only one CDR onto a framework

apply(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, pose_in: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::CloseOneCDRLoop::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, : pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop) → pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop¶: C++: protocols::antibody::CloseOneCDRLoop::operator=(const class protocols::antibody::CloseOneCDRLoop &) –> class protocols::antibody::CloseOneCDRLoop &

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>

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::CloseOneCDRLoop::enable_benchmark_mode(bool) –> 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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.CloseOneCDRLoop) → str¶: C++: protocols::antibody::CloseOneCDRLoop::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.CloseOneCDRLoop) → None¶: C++: protocols::antibody::CloseOneCDRLoop::set_default() –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.FrameWork¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.FrameWork, : pyrosetta.rosetta.protocols.antibody.FrameWork) → pyrosetta.rosetta.protocols.antibody.FrameWork¶: C++: protocols::antibody::FrameWork::operator=(const struct protocols::antibody::FrameWork &) –> struct protocols::antibody::FrameWork &

property chain_name¶

property start¶

property stop¶

class pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, : pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol) → pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol¶: C++: protocols::antibody::GraftCDRLoopsProtocol::operator=(const class protocols::antibody::GraftCDRLoopsProtocol &) –> class protocols::antibody::GraftCDRLoopsProtocol &

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.antibody.GraftCDRLoopsProtocol) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::GraftCDRLoopsProtocol::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>

display_constraint_residues(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::display_constraint_residues(class core::pose::Pose &) –> 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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.GraftCDRLoopsProtocol) → str¶: C++: protocols::antibody::GraftCDRLoopsProtocol::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static register_options() → None¶

Associates relevant options with the AntibodyModeler class

C++: protocols::antibody::GraftCDRLoopsProtocol::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_benchmark(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, benchmark: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_benchmark(bool) –> void

set_camelid(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, camelid: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_camelid(bool) –> void

set_camelid_constraints(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, camelid_constraints: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_camelid_constraints(bool) –> void

set_cst_weight(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, cst_weight: float) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_cst_weight(double) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol) → None¶

Assigns default values to primitive members

C++: protocols::antibody::GraftCDRLoopsProtocol::set_default() –> void

set_graft_h1(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, graft_h1: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_graft_h1(bool) –> void

set_graft_h2(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, graft_h2: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_graft_h2(bool) –> void

set_graft_h3(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, graft_h3: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_graft_h3(bool) –> void

set_graft_l1(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, graft_l1: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_graft_l1(bool) –> void

set_graft_l2(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, graft_l2: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_graft_l2(bool) –> void

set_graft_l3(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, graft_l3: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_graft_l3(bool) –> void

set_h3_stem_graft(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, h3_stem_graft: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_h3_stem_graft(bool) –> 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_packonly_after_graft(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, setting: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_packonly_after_graft(bool) –> void

set_rt_min(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, rtmin: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_rt_min(bool) –> void

set_sc_min(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, scmin: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_sc_min(bool) –> void

set_stem_optimize(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, setting: bool) → None¶: C++: protocols::antibody::GraftCDRLoopsProtocol::set_stem_optimize(bool) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol) -> None
show(self: pyrosetta.rosetta.protocols.antibody.GraftCDRLoopsProtocol, out: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::antibody::GraftCDRLoopsProtocol::show(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop¶

Bases: Mover

Grafts only one CDR onto a framework

apply(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, pose_in: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::GraftOneCDRLoop::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, rhs: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop) → pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop¶

assignment operator

C++: protocols::antibody::GraftOneCDRLoop::operator=(const class protocols::antibody::GraftOneCDRLoop &) –> class protocols::antibody::GraftOneCDRLoop &

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>

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::GraftOneCDRLoop::enable_benchmark_mode(bool) –> 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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.GraftOneCDRLoop) → str¶: C++: protocols::antibody::GraftOneCDRLoop::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_flank_size(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, setting: int) → None¶: C++: protocols::antibody::GraftOneCDRLoop::set_flank_size(unsigned long) –> 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_no_stem_copy(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, setting: bool) → None¶

R2 just graft R2 by copying some stem residues, and remove H3 to do: H3 loop modeling later. But the terminal has been changed by this grafting. Therefore, in R3, an option for not copying h3 stem is provided.

C++: protocols::antibody::GraftOneCDRLoop::set_no_stem_copy(const bool &) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.antibody.GraftOneCDRLoop, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

users can pass their own scorefunction for packing after grafting

C++: protocols::antibody::GraftOneCDRLoop::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer¶

Bases: Mover

Grafts only one CDR onto a framework

apply(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::GraftedStemOptimizer::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, rhs: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer) → pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer¶

assignment operator

C++: protocols::antibody::GraftedStemOptimizer::operator=(const class protocols::antibody::GraftedStemOptimizer &) –> class protocols::antibody::GraftedStemOptimizer &

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>

enable_benchmark_mode(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: bool) → None¶

enable benchmark mode

C++: protocols::antibody::GraftedStemOptimizer::enable_benchmark_mode(const bool &) –> 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_Cstem_foldtree(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::GraftedStemOptimizer::get_Cstem_foldtree(const class core::pose::Pose &) const –> class std::shared_ptr<class core::kinematics::FoldTree>

get_N_C_stems_foldtree(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::GraftedStemOptimizer::get_N_C_stems_foldtree(const class core::pose::Pose &) const –> class std::shared_ptr<class core::kinematics::FoldTree>

get_Nstem_foldtree(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::antibody::GraftedStemOptimizer::get_Nstem_foldtree(const class core::pose::Pose &) const –> class std::shared_ptr<class core::kinematics::FoldTree>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.GraftedStemOptimizer) → str¶: C++: protocols::antibody::GraftedStemOptimizer::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_stem_movemap(*args, **kwargs)¶

Overloaded function.

get_stem_movemap(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str) -> pyrosetta.rosetta.core.kinematics.MoveMap
get_stem_movemap(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str, include_nb_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::GraftedStemOptimizer::get_stem_movemap(const class core::pose::Pose &, const std::string &, const bool &) const –> class std::shared_ptr<class core::kinematics::MoveMap>

get_stem_taskfactory(*args, **kwargs)¶

Overloaded function.

get_stem_taskfactory(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str) -> pyrosetta.rosetta.core.pack.task.TaskFactory
get_stem_taskfactory(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, pose: pyrosetta.rosetta.core.pose.Pose, type: str, include_nb_sc: bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::antibody::GraftedStemOptimizer::get_stem_taskfactory(class core::pose::Pose &, const std::string &, const bool &) const –> class std::shared_ptr<class core::pack::task::TaskFactory>

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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_deep_optimization(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: bool) → None¶

deep optimization will do small_share_ccd

C++: protocols::antibody::GraftedStemOptimizer::set_deep_optimization(const bool &) –> 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_scorefxn(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

users can pass their own scorefunction, foldtree, movemap, and taskfactory

C++: protocols::antibody::GraftedStemOptimizer::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_stem_size(self: pyrosetta.rosetta.protocols.antibody.GraftedStemOptimizer, setting: int) → None¶

stem that was replaced by the extra reesidues at the end of the: loop terminus. Default is “2”

C++: protocols::antibody::GraftedStemOptimizer::set_stem_size(const unsigned long &) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.H3BaseTypeEnum¶

Bases: pybind11_object

Members:

Kinked

Extended

Neutral

Unknown

H3BaseTypeEnum_start

H3BaseTypeEnum_total

Extended = <H3BaseTypeEnum.Extended: 2>¶

H3BaseTypeEnum_start = <H3BaseTypeEnum.Kinked: 1>¶

H3BaseTypeEnum_total = <H3BaseTypeEnum.Unknown: 4>¶

Kinked = <H3BaseTypeEnum.Kinked: 1>¶

Neutral = <H3BaseTypeEnum.Neutral: 3>¶

Unknown = <H3BaseTypeEnum.Unknown: 4>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.antibody.H3CterInsert¶

Bases: Mover

H3 CDR, Fragment Insertion and CCD

apply(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::H3CterInsert::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert, : pyrosetta.rosetta.protocols.antibody.H3CterInsert) → pyrosetta.rosetta.protocols.antibody.H3CterInsert¶: C++: protocols::antibody::H3CterInsert::operator=(const class protocols::antibody::H3CterInsert &) –> class protocols::antibody::H3CterInsert &

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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.H3CterInsert) → str¶: C++: protocols::antibody::H3CterInsert::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

read_H3_cter_fragment(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::H3CterInsert::read_H3_cter_fragment(const class core::pose::Pose &) –> void

static 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¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.H3CterInsert) → None¶: C++: protocols::antibody::H3CterInsert::set_default() –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.H3PerturbCCD¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.H3PerturbCCD, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::H3PerturbCCD::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.H3PerturbCCD, : pyrosetta.rosetta.protocols.antibody.H3PerturbCCD) → pyrosetta.rosetta.protocols.antibody.H3PerturbCCD¶: C++: protocols::antibody::H3PerturbCCD::operator=(const class protocols::antibody::H3PerturbCCD &) –> class protocols::antibody::H3PerturbCCD &

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.antibody.H3PerturbCCD) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::H3PerturbCCD::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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.H3PerturbCCD) → str¶: C++: protocols::antibody::H3PerturbCCD::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

pass_the_loop(self: pyrosetta.rosetta.protocols.antibody.H3PerturbCCD, input_loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶: C++: protocols::antibody::H3PerturbCCD::pass_the_loop(class protocols::loops::Loop &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

read_and_store_fragments(self: pyrosetta.rosetta.protocols.antibody.H3PerturbCCD) → None¶: C++: protocols::antibody::H3PerturbCCD::read_and_store_fragments() –> void

static 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¶: 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 std::string &) –> 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_lowres_score_func(self: pyrosetta.rosetta.protocols.antibody.H3PerturbCCD, lowres_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

set scorefunction for low resolution of CDR H3 modeling

C++: protocols::antibody::H3PerturbCCD::set_lowres_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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¶

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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

turn_off_H3_filter(self: pyrosetta.rosetta.protocols.antibody.H3PerturbCCD) → None¶: C++: protocols::antibody::H3PerturbCCD::turn_off_H3_filter() –> void

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.H3RefineCCD¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::H3RefineCCD::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD, : pyrosetta.rosetta.protocols.antibody.H3RefineCCD) → pyrosetta.rosetta.protocols.antibody.H3RefineCCD¶: C++: protocols::antibody::H3RefineCCD::operator=(const class protocols::antibody::H3RefineCCD &) –> class protocols::antibody::H3RefineCCD &

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.antibody.H3RefineCCD) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::H3RefineCCD::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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.H3RefineCCD) → str¶: C++: protocols::antibody::H3RefineCCD::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

pass_start_pose(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD, start_pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::H3RefineCCD::pass_start_pose(class core::pose::Pose &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_highres_score_func(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD, highres_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::H3RefineCCD::set_highres_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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_task_factory(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::H3RefineCCD::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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

turn_off_flank_relax(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD) → None¶: C++: protocols::antibody::H3RefineCCD::turn_off_flank_relax() –> void

turn_off_h3_filter(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD) → None¶: C++: protocols::antibody::H3RefineCCD::turn_off_h3_filter() –> void

turn_on_benchmark(self: pyrosetta.rosetta.protocols.antibody.H3RefineCCD) → None¶: C++: protocols::antibody::H3RefineCCD::turn_on_benchmark() –> void

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::LHRepulsiveRamp::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, : pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp) → pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp¶: C++: protocols::antibody::LHRepulsiveRamp::operator=(const class protocols::antibody::LHRepulsiveRamp &) –> class protocols::antibody::LHRepulsiveRamp &

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.antibody.LHRepulsiveRamp) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::LHRepulsiveRamp::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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.LHRepulsiveRamp) → str¶: C++: protocols::antibody::LHRepulsiveRamp::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_default() –> void

set_dock_jump(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, jump: pyrosetta.rosetta.utility.vector1_int) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_dock_jump(class utility::vector1<int, class std::allocator<int> >) –> void

set_dock_score_func(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, dock_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_dock_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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_move_map(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_move_map(class std::shared_ptr<const class core::kinematics::MoveMap>) –> 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_pack_score_func(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, pack_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_pack_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_rot_mag(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, rot_mag: float) → float¶: C++: protocols::antibody::LHRepulsiveRamp::set_rot_mag(double) –> double

set_rt_min(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, rt_min: bool) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_rt_min(bool) –> void

set_sc_min(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, sc_min: bool) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_sc_min(bool) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::LHRepulsiveRamp::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

set_trans_mag(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRamp, trans_mag: float) → float¶: C++: protocols::antibody::LHRepulsiveRamp::set_trans_mag(double) –> double

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::LHRepulsiveRampLegacy::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, : pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy) → pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy¶: C++: protocols::antibody::LHRepulsiveRampLegacy::operator=(const class protocols::antibody::LHRepulsiveRampLegacy &) –> class protocols::antibody::LHRepulsiveRampLegacy &

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.antibody.LHRepulsiveRampLegacy) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::LHRepulsiveRampLegacy::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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.LHRepulsiveRampLegacy) → str¶: C++: protocols::antibody::LHRepulsiveRampLegacy::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy) → None¶: C++: protocols::antibody::LHRepulsiveRampLegacy::set_default() –> void

set_dock_score_func(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, dock_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::LHRepulsiveRampLegacy::set_dock_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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_pack_score_func(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, pack_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::LHRepulsiveRampLegacy::set_pack_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_rot_mag(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, rot_mag: float) → float¶: C++: protocols::antibody::LHRepulsiveRampLegacy::set_rot_mag(double) –> double

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::LHRepulsiveRampLegacy::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

set_trans_mag(self: pyrosetta.rosetta.protocols.antibody.LHRepulsiveRampLegacy, trans_mag: float) → float¶: C++: protocols::antibody::LHRepulsiveRampLegacy::set_trans_mag(double) –> double

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::LHSnugFitLegacy::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy, : pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy) → pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy¶: C++: protocols::antibody::LHSnugFitLegacy::operator=(const class protocols::antibody::LHSnugFitLegacy &) –> class protocols::antibody::LHSnugFitLegacy &

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.antibody.LHSnugFitLegacy) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::antibody::LHSnugFitLegacy::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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.LHSnugFitLegacy) → str¶: C++: protocols::antibody::LHSnugFitLegacy::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_default(self: pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy) → None¶: C++: protocols::antibody::LHSnugFitLegacy::set_default() –> 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_task_factory(self: pyrosetta.rosetta.protocols.antibody.LHSnugFitLegacy, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::LHSnugFitLegacy::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.antibody.LightChainTypeEnum¶

Bases: pybind11_object

Members:

lambda

kappa

lambda6

unknown

LightChainTypeEnum_start

LightChainTypeEnum_total

LightChainTypeEnum_start = <LightChainTypeEnum.lambda: 1>¶

LightChainTypeEnum_total = <LightChainTypeEnum.unknown: 4>¶

kappa = <LightChainTypeEnum.kappa: 2>¶

lambda = <LightChainTypeEnum.lambda: 1>¶

lambda6 = <LightChainTypeEnum.lambda6: 3>¶

property name¶

unknown = <LightChainTypeEnum.unknown: 4>¶

property value¶

class pyrosetta.rosetta.protocols.antibody.PDBLandmark¶

Bases: pybind11_object

Class that was once a struct; Used for matching pdb information between numbering schemes and cdr definitions.

assign(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark, : pyrosetta.rosetta.protocols.antibody.PDBLandmark) → pyrosetta.rosetta.protocols.antibody.PDBLandmark¶: C++: protocols::antibody::PDBLandmark::operator=(const class protocols::antibody::PDBLandmark &) –> class protocols::antibody::PDBLandmark &

chain(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → str¶: C++: protocols::antibody::PDBLandmark::chain() const –> char

get_string(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → str¶: C++: protocols::antibody::PDBLandmark::get_string() const –> std::string

insertion_code(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → str¶: C++: protocols::antibody::PDBLandmark::insertion_code() const –> char

numbering_scheme(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum¶: C++: protocols::antibody::PDBLandmark::numbering_scheme() const –> enum protocols::antibody::AntibodyNumberingSchemeEnum

resnum(self: pyrosetta.rosetta.protocols.antibody.PDBLandmark) → int¶: C++: protocols::antibody::PDBLandmark::resnum() const –> unsigned long

class pyrosetta.rosetta.protocols.antibody.PackingAngleEnum¶

Bases: pybind11_object

These are used to determine the VL_VH packing angle.

Members:

VL_sheet_1

VL_sheet_2

VH_sheet_1

VH_sheet_2

PackingAngleEnum_start

PackingAngleEnum_total

PackingAngleEnum_start = <PackingAngleEnum.VL_sheet_1: 1>¶

PackingAngleEnum_total = <PackingAngleEnum.VH_sheet_2: 4>¶

VH_sheet_1 = <PackingAngleEnum.VH_sheet_1: 3>¶

VH_sheet_2 = <PackingAngleEnum.VH_sheet_2: 4>¶

VL_sheet_1 = <PackingAngleEnum.VL_sheet_1: 1>¶

VL_sheet_2 = <PackingAngleEnum.VL_sheet_2: 2>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.antibody.ParatopeMetric_double_t¶

Bases: pybind11_object

property cdr¶

property paratope¶

property paratope_heavy¶

property paratope_light¶

class pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t, : pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t) → pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t¶: C++: protocols::antibody::ParatopeMetric<long>::operator=(const struct protocols::antibody::ParatopeMetric<long> &) –> struct protocols::antibody::ParatopeMetric<long> &

property cdr¶

property paratope¶

property paratope_heavy¶

property paratope_light¶

class pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel¶

Bases: Mover

apply(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, pose_in: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::antibody::RefineBetaBarrel::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, : pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel) → pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel¶: C++: protocols::antibody::RefineBetaBarrel::operator=(const class protocols::antibody::RefineBetaBarrel &) –> class protocols::antibody::RefineBetaBarrel &

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>

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.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

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.antibody.RefineBetaBarrel) → str¶: C++: protocols::antibody::RefineBetaBarrel::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_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

static name() → str¶: C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static 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¶: 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 std::string &) –> void

set_dock_score_func(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, dock_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::RefineBetaBarrel::set_dock_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> 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_pack_score_func(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, pack_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::antibody::RefineBetaBarrel::set_pack_score_func(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_rt_min(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, rt_min: bool) → None¶: C++: protocols::antibody::RefineBetaBarrel::set_rt_min(bool) –> void

set_sc_min(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, sc_min: bool) → None¶: C++: protocols::antibody::RefineBetaBarrel::set_sc_min(bool) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: C++: protocols::antibody::RefineBetaBarrel::set_task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(std::ostream &) 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

turn_off_repulsive_ramp(self: pyrosetta.rosetta.protocols.antibody.RefineBetaBarrel) → None¶: C++: protocols::antibody::RefineBetaBarrel::turn_off_repulsive_ramp() –> void

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

pyrosetta.rosetta.protocols.antibody.align_to_native(*args, **kwargs)¶

Overloaded function.

align_to_native(pose: pyrosetta.rosetta.core.pose.Pose, native_pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, native_ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None
align_to_native(pose: pyrosetta.rosetta.core.pose.Pose, native_pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, native_ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, request_chain: str) -> None

align current Fv to native.Fv

C++: protocols::antibody::align_to_native(class core::pose::Pose &, const class core::pose::Pose &, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>, const std::string &) –> void

pyrosetta.rosetta.protocols.antibody.attributes_for_get_cdr_bool_from_tag(*args, **kwargs)¶

Overloaded function.

attributes_for_get_cdr_bool_from_tag(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, tagname: str) -> None
attributes_for_get_cdr_bool_from_tag(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, tagname: str, Description: str) -> None

C++: protocols::antibody::attributes_for_get_cdr_bool_from_tag(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.protocols.antibody.cdr_CN_anchor_distance(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: protocols::antibody::AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → float¶

Calculate the distance between the carbon and nitrogen of each residue before and after the CDR respectively

C++: protocols::antibody::cdr_CN_anchor_distance(const class core::pose::Pose &, class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const enum protocols::antibody::CDRNameEnum &) –> double

pyrosetta.rosetta.protocols.antibody.cdr_backbone_rmsds(*args, **kwargs)¶

Overloaded function.

cdr_backbone_rmsds(p1: pyrosetta.rosetta.core.pose.Pose, p2: pyrosetta.rosetta.core.pose.Pose, a1: protocols::antibody::AntibodyInfo, a2: protocols::antibody::AntibodyInfo) -> pyrosetta.rosetta.utility.vector1_double
cdr_backbone_rmsds(p1: pyrosetta.rosetta.core.pose.Pose, p2: pyrosetta.rosetta.core.pose.Pose, a1: protocols::antibody::AntibodyInfo, a2: protocols::antibody::AntibodyInfo, aln_thresh: int) -> pyrosetta.rosetta.utility.vector1_double

Align two sequence matching antibodies and calculate CDR rmsds (add OCD), then store in scores

vector is made up of: OCD FRH H1 RMS H2 RMS H3 RMS FRL L1 RMS L2 RMS L3 RMS

C++: protocols::antibody::cdr_backbone_rmsds(class core::pose::Pose &, const class core::pose::Pose &, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>, unsigned long) –> class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.protocols.antibody.cdr_energy(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: protocols::antibody::AntibodyInfo, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → float¶

Calculates energy of cdr by decomposing scorefxn into pair and then summing. This means it includes hbonding components, etc.

C++: protocols::antibody::cdr_energy(const class core::pose::Pose &, class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class std::shared_ptr<const class core::scoring::ScoreFunction>, const enum protocols::antibody::CDRNameEnum &) –> double

pyrosetta.rosetta.protocols.antibody.check_fix_aho_cdr_numbering(*args, **kwargs)¶

Overloaded function.

check_fix_aho_cdr_numbering(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Checks the length of the CDR, fixes AHO numbering for longer CDR loops that don’t: fit within the numbering scheme

C++: protocols::antibody::check_fix_aho_cdr_numbering(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, enum protocols::antibody::CDRNameEnum, class core::pose::Pose &) –> void

check_fix_aho_cdr_numbering(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::antibody::check_fix_aho_cdr_numbering(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.antibody.cutpoint_separation(pose_in: pyrosetta.rosetta.core.pose.Pose, cutpoint: int) → float¶

Compute the separation at the cutpoint. The N-C distance of the: peptide bond which should be formed at the cutpoint. A closed loop is assumed to have a gap < 1.9 Ang

C++: protocols::antibody::cutpoint_separation(class core::pose::Pose &, unsigned long) –> double

pyrosetta.rosetta.protocols.antibody.cutpoints_separation(pose: pyrosetta.rosetta.core.pose.Pose, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → bool¶

return false if any cdr cutpoint is broken

C++: protocols::antibody::cutpoints_separation(class core::pose::Pose &, class std::shared_ptr<class protocols::antibody::AntibodyInfo> &) –> bool

pyrosetta.rosetta.protocols.antibody.deep_copy(source: protocols::antibody::AntibodyInfo) → protocols::antibody::AntibodyInfo¶: C++: protocols::antibody::deep_copy(const class protocols::antibody::AntibodyInfo &) –> class std::shared_ptr<class protocols::antibody::AntibodyInfo>

pyrosetta.rosetta.protocols.antibody.get_cdr_bool_from_tag(*args, **kwargs)¶

Overloaded function.

get_cdr_bool_from_tag(tag: pyrosetta.rosetta.utility.tag.Tag, name: str) -> pyrosetta.rosetta.utility.vector1_bool
get_cdr_bool_from_tag(tag: pyrosetta.rosetta.utility.tag.Tag, name: str, include_cdr4: bool) -> pyrosetta.rosetta.utility.vector1_bool

Geta boolean vector of CDRs from a RosettaScripts tag. Companion function for XSD generation: attributes_for_get_cdr_bool_from_tag

C++: protocols::antibody::get_cdr_bool_from_tag(class std::shared_ptr<const class utility::tag::Tag>, const std::string &, bool) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.get_cdr_loops(*args, **kwargs)¶

Overloaded function.

get_cdr_loops(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> pyrosetta.rosetta.protocols.loops.Loops
get_cdr_loops(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, stem_size: int) -> pyrosetta.rosetta.protocols.loops.Loops

Get a set of loops for a boolean vector of CDRNameEnums including any stem residues.

C++: protocols::antibody::get_cdr_loops(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, unsigned long) –> class std::shared_ptr<class protocols::loops::Loops>

pyrosetta.rosetta.protocols.antibody.get_conserved_residue_list(chain: str) → pyrosetta.rosetta.utility.vector1_double¶

return vector of Chothia-nubmered, conserved residues for grafting and alignment

C++: protocols::antibody::get_conserved_residue_list(char) –> class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.protocols.antibody.get_matching_landmark(numbering: pyrosetta.rosetta.protocols.antibody.AntibodyNumbering, landmark: pyrosetta.rosetta.protocols.antibody.PDBLandmark, from_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum, to_scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → pyrosetta.rosetta.protocols.antibody.PDBLandmark¶

get the equivalent landmark in a numbering scheme. Set the resnum to zero if not found.

C++: protocols::antibody::get_matching_landmark(const struct protocols::antibody::AntibodyNumbering &, const class protocols::antibody::PDBLandmark &, const enum protocols::antibody::AntibodyNumberingSchemeEnum, const enum protocols::antibody::AntibodyNumberingSchemeEnum) –> class std::shared_ptr<const class protocols::antibody::PDBLandmark>

pyrosetta.rosetta.protocols.antibody.global_loop_rmsd(pose_in: pyrosetta.rosetta.core.pose.Pose, native_pose: pyrosetta.rosetta.core.pose.Pose, current_loop: pyrosetta.rosetta.protocols.loops.Loops) → float¶

/////////////////////////////////////// things to compare to native //////////////////////////////////////////

C++: protocols::antibody::global_loop_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<class protocols::loops::Loops>) –> double

pyrosetta.rosetta.protocols.antibody.is_H3_rama_kinked(rama: str) → bool¶

Very basic kink function based on rama groups. Kink is defined as having AB + DB at the C-terminal stem.: This is in the North/Dunbrack CDR definition. Avoid this definition if you can and talk to brain. This is currently used for a quick filtering for design.

C++: protocols::antibody::is_H3_rama_kinked(const std::string &) –> bool

pyrosetta.rosetta.protocols.antibody.kink_RD_Hbond(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo) → float¶: C++: protocols::antibody::kink_RD_Hbond(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> double

pyrosetta.rosetta.protocols.antibody.kink_Trp_Hbond(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo) → float¶: C++: protocols::antibody::kink_Trp_Hbond(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> double

pyrosetta.rosetta.protocols.antibody.kink_bb_Hbond(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo) → float¶: C++: protocols::antibody::kink_bb_Hbond(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> double

pyrosetta.rosetta.protocols.antibody.kink_constrain_antibody_H3(*args, **kwargs)¶

Overloaded function.

kink_constrain_antibody_H3(pose: pyrosetta.rosetta.core.pose.Pose, kink_begin: int) -> None

Apply auto-generated kink constraint

C++: protocols::antibody::kink_constrain_antibody_H3(class core::pose::Pose &, unsigned long) –> void

kink_constrain_antibody_H3(pose: pyrosetta.rosetta.core.pose.Pose, antibody_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) -> None

C++: protocols::antibody::kink_constrain_antibody_H3(class core::pose::Pose &, const class std::shared_ptr<class protocols::antibody::AntibodyInfo>) –> void

pyrosetta.rosetta.protocols.antibody.kink_dihedral(*args, **kwargs)¶

Overloaded function.

kink_dihedral(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo) -> Tuple[float, float]
kink_dihedral(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo, debug: bool) -> Tuple[float, float]

C++: protocols::antibody::kink_dihedral(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &, bool) –> struct std::pair<double, double>

pyrosetta.rosetta.protocols.antibody.paratope_charge(*args, **kwargs)¶

Overloaded function.

paratope_charge(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo) -> pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t
paratope_charge(pose: pyrosetta.rosetta.core.pose.Pose, abinfo: protocols::antibody::AntibodyInfo, include_de_loop: bool) -> pyrosetta.rosetta.protocols.antibody.ParatopeMetric_long_t

calculate the net charge of the paratope

C++: protocols::antibody::paratope_charge(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &, bool) –> struct protocols::antibody::ParatopeMetric<long>

pyrosetta.rosetta.protocols.antibody.paratope_sasa(*args, **kwargs)¶

Overloaded function.

paratope_sasa(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: protocols::antibody::AntibodyInfo) -> Tuple[pyrosetta.rosetta.protocols.antibody.ParatopeMetric_double_t, pyrosetta.rosetta.protocols.antibody.ParatopeMetric_double_t]
paratope_sasa(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: protocols::antibody::AntibodyInfo, include_de_loop: bool) -> Tuple[pyrosetta.rosetta.protocols.antibody.ParatopeMetric_double_t, pyrosetta.rosetta.protocols.antibody.ParatopeMetric_double_t]

calculate the SASA of the antibody paratope. Returns all and hydrophobic components.

C++: protocols::antibody::paratope_sasa(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &, bool) –> struct std::pair<struct protocols::antibody::ParatopeMetric<double>, struct protocols::antibody::ParatopeMetric<double> >

pyrosetta.rosetta.protocols.antibody.pose_charge(pose: pyrosetta.rosetta.core.pose.Pose) → int¶

calculate the net charge of the antibody

C++: protocols::antibody::pose_charge(const class core::pose::Pose &) –> long

pyrosetta.rosetta.protocols.antibody.qq_constrain_antibody(pose: pyrosetta.rosetta.core.pose.Pose, VH_qq_resi: int, VL_qq_resi: int) → None¶: C++: protocols::antibody::qq_constrain_antibody(class core::pose::Pose &, unsigned long, unsigned long) –> void

pyrosetta.rosetta.protocols.antibody.select_epitope_residues(*args, **kwargs)¶

Overloaded function.

select_epitope_residues(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_bool
select_epitope_residues(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, interface_distance: int) -> pyrosetta.rosetta.utility.vector1_bool

Get the epitope residues using the InterGroupNeighborsCalculator.

C++: protocols::antibody::select_epitope_residues(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.setup_A_LH_foldtree(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Setup A_LH foldtree via docking. Return dock_chains string.

C++: protocols::antibody::setup_A_LH_foldtree(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.antibody.setup_LH_A_foldtree(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → str¶

Setup LH_A foldtree via docking. Return dock_chains string.

C++: protocols::antibody::setup_LH_A_foldtree(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.antibody.setup_packer_task(pose_in: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.TaskFactory¶

Very specific packertask,

Ubound rotamer options, repack only, protein only, no disulfides.

C++: protocols::antibody::setup_packer_task(class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

pyrosetta.rosetta.protocols.antibody.simple_fold_tree(pose_in: pyrosetta.rosetta.core.pose.Pose, jumppoint1: int, cutpoint: int, jumppoint2: int) → None¶: C++: protocols::antibody::simple_fold_tree(class core::pose::Pose &, unsigned long, unsigned long, unsigned long) –> void

pyrosetta.rosetta.protocols.antibody.simple_one_loop_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose, loop: pyrosetta.rosetta.protocols.loops.Loop) → None¶

////////////////////////////// Etc. /////////////////////////////////////

C++: protocols::antibody::simple_one_loop_fold_tree(class core::pose::Pose &, const class protocols::loops::Loop &) –> void

pyrosetta.rosetta.protocols.antibody.vl_vh_orientation_coords(pose_in: pyrosetta.rosetta.core.pose.Pose, ab_info: protocols::antibody::AntibodyInfo) → pyrosetta.rosetta.utility.vector1_double¶

calculate the VH_VL packing angle from 2 sheet definitions on each antibody chain

vector is made up of:
vl_vh_distance opening_angle opposite_angle packing_angle

C++: protocols::antibody::vl_vh_orientation_coords(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> class utility::vector1<double, class std::allocator<double> >