design

Bindings for protocols::antibody::design namespace

class pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, : pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager) → pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager

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

design_protocol_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, design_protocol: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum) → str

C++: protocols::antibody::design::AntibodyDesignEnumManager::design_protocol_enum_to_string(const enum protocols::antibody::design::AntibodyDesignProtocolEnum) const –> std::string

design_protocol_is_present(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, design_protocol: str) → bool

C++: protocols::antibody::design::AntibodyDesignEnumManager::design_protocol_is_present(const std::string &) const –> bool

design_protocol_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, design_protocol: str) → pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum

/////////////// Design Protocol ///////////////////////////////////////////////

C++: protocols::antibody::design::AntibodyDesignEnumManager::design_protocol_string_to_enum(const std::string &) const –> enum protocols::antibody::design::AntibodyDesignProtocolEnum

get_recognized_design_protocols(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager) → pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::antibody::design::AntibodyDesignEnumManager::get_recognized_design_protocols() const –> class utility::vector1<std::string, class std::allocator<std::string > >

min_type_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, min_type: pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum) → str

C++: protocols::antibody::design::AntibodyDesignEnumManager::min_type_enum_to_string(const enum protocols::antibody::design::MinTypeEnum) const –> std::string

min_type_is_present(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, min_type: str) → bool

C++: protocols::antibody::design::AntibodyDesignEnumManager::min_type_is_present(const std::string &) const –> bool

min_type_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, min_type: str) → pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum

/////////////// MinType ///////////////////////////////////////////////

C++: protocols::antibody::design::AntibodyDesignEnumManager::min_type_string_to_enum(const std::string &) const –> enum protocols::antibody::design::MinTypeEnum

seq_design_strategy_enum_to_string(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, seq_design_strategy: pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum) → str

C++: protocols::antibody::design::AntibodyDesignEnumManager::seq_design_strategy_enum_to_string(const enum protocols::antibody::design::SeqDesignStrategyEnum) const –> std::string

seq_design_strategy_is_present(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, seq_design_strategy: str) → bool

C++: protocols::antibody::design::AntibodyDesignEnumManager::seq_design_strategy_is_present(const std::string &) const –> bool

seq_design_strategy_string_to_enum(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignEnumManager, seq_design_strategy: str) → pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum

/////////////// SeqDesignStrategy ///////////////////////////////////////////////

C++: protocols::antibody::design::AntibodyDesignEnumManager::seq_design_strategy_string_to_enum(const std::string &) const –> enum protocols::antibody::design::SeqDesignStrategyEnum

class pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover

Bases: Mover

This class designs antibodies by grafting, using cluster information and constraints to help. It represents the first step in The Rosetta Antibody Designer, but can be used outside of the application. A 2011 Antibody Database is included in the rosetta datase. Up-to-date versions can be downloaded from

To use this class: 1) Use default instruction path, or set one. Loads CDRs from AntibodyDatabase

*See rosetta_database/sampling/antibodies for file format.

2. Use class interface settings to control sampling. Loads CDRs from AntibodyDatabase.

3. Use set_cdr_sets to set your own CDRs to graft.

apply(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::antibody::design::AntibodyDesignMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, : pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) → pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover

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

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.design.AntibodyDesignMover) → pyrosetta.rosetta.protocols.moves.Mover

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

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

get_additional_output(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::antibody::design::AntibodyDesignMover::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.design.AntibodyDesignMover) → str

C++: protocols::antibody::design::AntibodyDesignMover::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_top_designs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t

Get the top designs found. You can then use them in other protocols, dump them, etc. They are in order.

• This should be refactored to get_additional_output.

C++: protocols::antibody::design::AntibodyDesignMover::get_top_designs() –> class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > >

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::design::AntibodyDesignMover::mover_name() –> std::string

static name() → str

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

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

Parse my tag for RosettaScripts. Main RS interface to full antibody design protocol.

C++: protocols::antibody::design::AntibodyDesignMover::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.design.AntibodyDesignMover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::antibody::design::AntibodyDesignMover::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_set_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, cdr_set_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t) → None

Set the options which will be used for querying the database

C++: protocols::antibody::design::AntibodyDesignMover::set_cdr_set_options(class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >) –> 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_defaults(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) → None

Reads default CDRGraftInstruction file and creates structs.

C++: protocols::antibody::design::AntibodyDesignMover::set_defaults() –> void

set_design_protocol(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, design_protocol: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum) → None

Set the design protocol. Default is classic_monte_carlo.

Available options are: generalized_monte_carlo, deterministc_graft.

. Deterministic Protocol only available if GraftDesigning a single CDR.

C++: protocols::antibody::design::AntibodyDesignMover::set_design_protocol(enum protocols::antibody::design::AntibodyDesignProtocolEnum) –> void

set_dock_first_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, dock_first_cycles: int) → None

Set the first cycles of the High-res MCM dock protocol.

Default for RAbD is 2. Default for FULL docking protocol is 4.

C++: protocols::antibody::design::AntibodyDesignMover::set_dock_first_cycles(unsigned long) –> void

set_dock_post_graft(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, dock_post_graft: bool) → None

Set the algorithm to run a low-resolution docking step after each graft. Default false.

Uses command-line options for docking. Lower inner or outer cycles if you are grafting many CDRs. Still quicker then relax.

C++: protocols::antibody::design::AntibodyDesignMover::set_dock_post_graft(bool) –> void

set_dock_rounds(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, dock_rounds: int) → None

C++: protocols::antibody::design::AntibodyDesignMover::set_dock_rounds(unsigned long) –> void

set_dock_second_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, dock_second_cycles: int) → None

Set the first cycles of the High-res MCM dock protocol.

Default for RAbD is 2. (Used as A SHORT optimization step) Default for FULL docking protocol is 45.

C++: protocols::antibody::design::AntibodyDesignMover::set_dock_second_cycles(unsigned long) –> void

set_epitope_residues(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, epitope_residues: pyrosetta.rosetta.utility.vector1_protocols_antibody_design_PDBNumbering) → None

Set any epitope residues in PDB numbering. If not set, they will be detected automatically via the interface.

C++: protocols::antibody::design::AntibodyDesignMover::set_epitope_residues(class utility::vector1<struct protocols::antibody::design::PDBNumbering, class std::allocator<struct protocols::antibody::design::PDBNumbering> >) –> void

set_graft_design_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, graft_design_cdrs: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) → None

Set the CDRs which will undergo Graft-Design

C++: protocols::antibody::design::AntibodyDesignMover::set_graft_design_cdrs(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

set_graft_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, graft_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t) → None

Set CDR-specific GraftDesign options

C++: protocols::antibody::design::AntibodyDesignMover::set_graft_design_options(class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions> > >) –> void

set_inner_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, inner_cycles: int) → None

Set the number of inner cycles, which optimizes the structure and sequence of the antibody after any graft.

Essentially min cycles.

C++: protocols::antibody::design::AntibodyDesignMover::set_inner_cycles(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_instruction_file(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, instruction_file: str) → None

Set the instruction file path to load options from instead of setting these via associated options functions

Or loading via cmd-line option. Gotta love supporting 3 different Rosetta interfaces.

C++: protocols::antibody::design::AntibodyDesignMover::set_instruction_file(std::string) –> void

set_interface_dis(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, interface_dis: float) → None

C++: protocols::antibody::design::AntibodyDesignMover::set_interface_dis(double) –> void

set_keep_top_designs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, top_designs: int) → None

Sets the protocol to keep a specific number of top designs. Default is 10

C++: protocols::antibody::design::AntibodyDesignMover::set_keep_top_designs(unsigned long) –> void

set_light_chain(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, light_chain: str) → None

Set the light chain - lambda or kappa.

C++: protocols::antibody::design::AntibodyDesignMover::set_light_chain(const std::string &) –> 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_neighbor_dis(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, neighbor_dis: float) → None

C++: protocols::antibody::design::AntibodyDesignMover::set_neighbor_dis(double) –> void

set_outer_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, outer_cycles: int) → None

Set the number of overall rounds. Each round will choose a CDR and design it and others based on options

Default = 25.

C++: protocols::antibody::design::AntibodyDesignMover::set_outer_cycles(unsigned long) –> void

set_paratope_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, cdrs: pyrosetta.rosetta.utility.vector1_bool) → None

Set any paratope CDRs. If not set, will use all CDRs as the paratope where needed.

Used mainly for constraints

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

set_primary_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, primary_cdrs: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) → None

Manually set the CDRs which can be chosen in the outer cycle.

These should be on for either Sequence-Design or Graft-Design. Normally, the outer cycles are whatever CDRs we are designing, including CDRs which are sequence-design only. Use this if you are primarily interested in specific CDRs

(such as graft-designing H3 and allowing H1 and L3 to sequence design during the inner cycle.

C++: protocols::antibody::design::AntibodyDesignMover::set_primary_cdrs(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

set_random_start(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, random_start: bool) → None

Set the protocol to start with random grafted CDRs for the CDRs set to graft design.

Useful for starting a high-energy structure or doing benchmarks.

C++: protocols::antibody::design::AntibodyDesignMover::set_random_start(const bool) –> void

set_relax_cycles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, relax_cycles: int) → None

Set the number of relax cycles to run after each outer cycles.

Only makes sense with mintype relax.

C++: protocols::antibody::design::AntibodyDesignMover::set_relax_cycles(unsigned long) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::antibody::design::AntibodyDesignMover::set_scorefunction(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_scorefunction_min(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, min_scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::antibody::design::AntibodyDesignMover::set_scorefunction_min(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_seq_design_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, seq_design_cdrs: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) → None

Set the CDRs which will undergo Sequence-Design

C++: protocols::antibody::design::AntibodyDesignMover::set_seq_design_cdrs(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

set_seq_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t) → None

Set CDR-specific SeqDesign options

C++: protocols::antibody::design::AntibodyDesignMover::set_seq_design_options(class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >) –> 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_epitope_constraints(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover, use_epitope_csts: bool) → None

Setting to use epitope constraints. Without this false, will not use any set epitope residues.

C++: protocols::antibody::design::AntibodyDesignMover::set_use_epitope_constraints(bool) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMover) -> None

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

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

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

Set the ‘type’ string

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

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

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMoverCreator, : pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMoverCreator) → pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMoverCreator

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

create_mover(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMoverCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::antibody::design::AntibodyDesignMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMoverCreator) → str

C++: protocols::antibody::design::AntibodyDesignMoverCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignMoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

C++: protocols::antibody::design::AntibodyDesignMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum

Bases: pybind11_object

Members:

generalized_monte_carlo

even_cluster_monte_carlo

even_length_cluster_monte_carlo

deterministic_graft

DesignProtocolEnum_total

DesignProtocolEnum_total = <AntibodyDesignProtocolEnum.deterministic_graft: 4>

deterministic_graft = <AntibodyDesignProtocolEnum.deterministic_graft: 4>

even_cluster_monte_carlo = <AntibodyDesignProtocolEnum.even_cluster_monte_carlo: 2>

even_length_cluster_monte_carlo = <AntibodyDesignProtocolEnum.even_length_cluster_monte_carlo: 3>

generalized_monte_carlo = <AntibodyDesignProtocolEnum.generalized_monte_carlo: 1>

property name

property value

class pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator

Bases: pybind11_object

Create a TaskFactory or individual TaskOperations based on a set of options These options are mainly for per-CDR and per-framework control of sequence design

assign(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, : pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator) → pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator

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

clone(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator) → pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator

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

design_antigen(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, antigen_design: bool) → None

Normally, we do not want to design the antigen residues - but perhaps someday we will.

If False, turn design off for the antigen for any TF creation.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::design_antigen(bool) –> void

design_framework(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, framework_design: bool) → None

Design any framework residues included in the task. Default True.

If False, turn design off for the framework for any TF creation.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::design_framework(bool) –> void

design_proline(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, setting: bool) → None

Keep proline fixed for design. If using profile design, this should not really come into play.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::design_proline(const bool) –> void

disable_design_for_non_designing_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → None

Turns off CDRs for design that are set to off.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::disable_design_for_non_designing_cdrs(class std::shared_ptr<class core::pack::task::TaskFactory>, const class core::pose::Pose &) –> void

disable_disallowed_aa(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::disable_disallowed_aa(class std::shared_ptr<class core::pack::task::TaskFactory>, const class core::pose::Pose &) const –> void

disable_proline_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::disable_proline_design(class std::shared_ptr<class core::pack::task::TaskFactory>, const class core::pose::Pose &) const –> void

generate_task_op_all_cdr_design(*args, **kwargs)

Overloaded function.

1. generate_task_op_all_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) -> protocols::simple_task_operations::RestrictToLoopsAndNeighbors

2. generate_task_op_all_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, design_neighbors: bool) -> protocols::simple_task_operations::RestrictToLoopsAndNeighbors

Create a TaskOp to limit Packing and Design to CDR loops and neighbors.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_all_cdr_design(const class core::pose::Pose &, bool) const –> class std::shared_ptr<class protocols::simple_task_operations::RestrictToLoopsAndNeighbors>

generate_task_op_cdr_design(*args, **kwargs)

Overloaded function.

1. generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) -> protocols::simple_task_operations::RestrictToLoopsAndNeighbors

2. generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, design_neighbors: bool) -> protocols::simple_task_operations::RestrictToLoopsAndNeighbors

Create a TaskOp to limit Packing and Design to only CDR loops with design on. Use neighbor distance.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_cdr_design(const class core::pose::Pose &, bool) const –> class std::shared_ptr<class protocols::simple_task_operations::RestrictToLoopsAndNeighbors>

3. generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool) -> protocols::simple_task_operations::RestrictToLoopsAndNeighbors

4. generate_task_op_cdr_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, design_neighbors: bool) -> protocols::simple_task_operations::RestrictToLoopsAndNeighbors

Create a TaskOp for only CDR loops set to True in the boolean vector.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_cdr_design(const class core::pose::Pose &, class utility::vector1<bool, class std::allocator<bool> >, bool) const –> class std::shared_ptr<class protocols::simple_task_operations::RestrictToLoopsAndNeighbors>

generate_task_op_cdr_profiles(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) → protocols::antibody::task_operations::AddCDRProfilesOperation

Setup the CDRProfilesOperation and conservative/basic design

according to primary and fallback strategies and which CDRs are set to design. Pre-load the data

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_task_op_cdr_profiles(const class core::pose::Pose &) –> class std::shared_ptr<class protocols::antibody::task_operations::AddCDRProfilesOperation>

generate_tf_seq_design(*args, **kwargs)

Overloaded function.

1. generate_tf_seq_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.TaskFactory

2. generate_tf_seq_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, disable_non_designing_cdrs: bool) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Create the FULL TaskFactory for antibody sequence design.

There are no limits to repacking or design - AKA NO RestrictToLoops. Optionally disable framework residues for design Optionally disable antigen residues for design. Optionally disable framework conservative residues -> Combine with other Tasks for general design requirements.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_tf_seq_design(const class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::TaskFactory>

generate_tf_seq_design_graft_design(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, neighbor_cdr_min: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.core.pack.task.TaskFactory

Create the TaskFactory used for sequence design during the GraftDesign stage.

This limits design to the passed CDR, optionally designing neighbor CDRs specified in options and included in min.

Basically will create a TF including CDRs you are minimizing and any neighbors. It will then use settings in your Options classes and class settings such as framework or antigen design to create the TF, disabling CDRs that are not allowed to design as well as framework or antigen regions.

Optionally design any neighbor framework residues Optionally design any neighbor antigen residues Optionally disable framework conservative residues

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::generate_tf_seq_design_graft_design(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum, const class utility::vector1<bool, class std::allocator<bool> > &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

get_cdr_design_options(*args, **kwargs)

Overloaded function.

1. get_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

Get modifiable options

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::get_cdr_design_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >

2. get_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) -> pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

Get modifiable options

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::get_cdr_design_options(enum protocols::antibody::CDRNameEnum) –> class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>

neighbor_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, neighbor_distance: float) → None

Repack neighbors of CDR’s being designed within this distance.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::neighbor_detection_dis(const double) –> void

set_cdr_design_options(*args, **kwargs)

Overloaded function.

1. set_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, design_options: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) -> None

Set design options for single CDR

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_cdr_design_options(enum protocols::antibody::CDRNameEnum, class std::shared_ptr<const class protocols::antibody::design::CDRSeqDesignOptions>) –> void

2. set_cdr_design_options(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t) -> None

Set design options for All CDRs

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_cdr_design_options(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> > >) –> void

set_design_H3_stem(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_H3_stem: bool) → None

Enable design of the first 2 and last 3 residues of the H3 loop. These are off by default as to help hinder the transition from extended

to kinked and vice versa during sequence design.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_design_H3_stem(bool) –> void

set_design_framework_conservative(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_framework_conservative: bool) → None

Use the Conservative Design TaskOP if designing Framework residues.

Default true. Recommended.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_design_framework_conservative(bool) –> void

set_design_framework_conserved_res(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, design_framework_conserved_res: bool) → None

Enable design of 100% conserved framework positions during TF generation.

Default false. Will be expanded.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_design_framework_conserved_res(bool) –> void

set_no_probability(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, no_probability: bool) → None

Set to sample all available AAs per position instead of sampling based on weights

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_no_probability(bool) –> void

set_probability_data_cutoff(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, cutoff: int) → None

Use conservative mutations (or alternative method) instead of using cluster sequence probabilities for design

if the number of sequences in the particular CDR’s cluster probability data is lower than this cutoff. Default is 10. This is why we try and stay in type 1 lengths during graft.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_probability_data_cutoff(const unsigned long) –> void

set_zero_prob_weight_at(self: pyrosetta.rosetta.protocols.antibody.design.AntibodySeqDesignTFCreator, weight: float) → None

Use these weights during probabilistic design for data that is normally zero.

C++: protocols::antibody::design::AntibodySeqDesignTFCreator::set_zero_prob_weight_at(const double) –> void

class pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions

Bases: pybind11_object

Class that holds CDRGraftDesign Options. Now that GraftDesign is not a separate ‘thing’, this should be split into CDRGraftOptions and CDRMinOptions eventually.

assign(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, : pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) → pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions

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

clone(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) → pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions

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

design(*args, **kwargs)

Overloaded function.

1. design(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, design: bool) -> None

Should this CDR be designed?

C++: protocols::antibody::design::CDRGraftDesignOptions::design(bool) –> void

2. design(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

Should this CDR be designed?

C++: protocols::antibody::design::CDRGraftDesignOptions::design() const –> bool

min_neighbor_sc(*args, **kwargs)

Overloaded function.

1. min_neighbor_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, min_neighbor_sc: bool) -> None

Minimize neighbor sidechains?

C++: protocols::antibody::design::CDRGraftDesignOptions::min_neighbor_sc(bool) –> void

2. min_neighbor_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

C++: protocols::antibody::design::CDRGraftDesignOptions::min_neighbor_sc() const –> bool

min_rb(*args, **kwargs)

Overloaded function.

1. min_rb(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, min_rb: bool) -> None

Use rigid body optimization during minimization of the CDR (Minimize jump bt antigen and antibody)?

Does nothing if repacking the cdr. Default False.

C++: protocols::antibody::design::CDRGraftDesignOptions::min_rb(bool) –> void

2. min_rb(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

C++: protocols::antibody::design::CDRGraftDesignOptions::min_rb() const –> bool

min_sc(*args, **kwargs)

Overloaded function.

1. min_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, min_sc: bool) -> None

Minimize sidechains during minimization (relax/min/etc) (default True?

C++: protocols::antibody::design::CDRGraftDesignOptions::min_sc(bool) –> void

2. min_sc(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> bool

C++: protocols::antibody::design::CDRGraftDesignOptions::min_sc() const –> bool

mintype(*args, **kwargs)

Overloaded function.

1. mintype(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, mintype: pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum) -> None

Options are: relax, minimize, repack, dualspace. Default is repack for time, but relax is the best

C++: protocols::antibody::design::CDRGraftDesignOptions::mintype(enum protocols::antibody::design::MinTypeEnum) –> void

2. mintype(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum

C++: protocols::antibody::design::CDRGraftDesignOptions::mintype() const –> enum protocols::antibody::design::MinTypeEnum

neighbor_min(*args, **kwargs)

Overloaded function.

1. neighbor_min(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, neighbor_min: pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum) -> None

Set other CDRs to minimize when this CDR is minimized

C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min(class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >) –> void

2. neighbor_min(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> pyrosetta.rosetta.utility.vector1_protocols_antibody_CDRNameEnum

C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min() const –> class utility::vector1<enum protocols::antibody::CDRNameEnum, class std::allocator<enum protocols::antibody::CDRNameEnum> >

neighbor_min_add(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None

C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min_add(enum protocols::antibody::CDRNameEnum) –> void

neighbor_min_clear(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) → None

C++: protocols::antibody::design::CDRGraftDesignOptions::neighbor_min_clear() –> void

set_cdr(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None

Set the CDR type for this instance of options.

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

set_defaults(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) → None

Set defaults - !!! these are not the defaults from the database default instruction file.

Use the parser to parse those instructions if you wish.

C++: protocols::antibody::design::CDRGraftDesignOptions::set_defaults() –> void

weight(*args, **kwargs)

Overloaded function.

1. weight(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions, weight: float) -> None

Set the weight we will use for choosing this particular CDR for design.

C++: protocols::antibody::design::CDRGraftDesignOptions::weight(double) –> void

2. weight(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions) -> float

Return the weight we will use for choosing this particular CDR for design.

C++: protocols::antibody::design::CDRGraftDesignOptions::weight() const –> double

class pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser, : pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser) → pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser

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

clone(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser) → pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser

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

parse_default_and_user_options(*args, **kwargs)

Overloaded function.

1. parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions

Parse default_instructions (mainly used for AbDesign) then parse user file

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

2. parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t

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

parse_options(*args, **kwargs)

Overloaded function.

1. parse_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptions

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

2. parse_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRGraftDesignOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t

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

class pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions, : pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) → pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

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

cdr(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) → pyrosetta.rosetta.protocols.antibody.CDRNameEnum

C++: protocols::antibody::design::CDRSeqDesignOptions::cdr() const –> enum protocols::antibody::CDRNameEnum

clone(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) → pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

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

design(*args, **kwargs)

Overloaded function.

1. design(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions, design: bool) -> None

C++: protocols::antibody::design::CDRSeqDesignOptions::design(bool) –> void

2. design(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) -> bool

C++: protocols::antibody::design::CDRSeqDesignOptions::design() const –> bool

design_strategy(*args, **kwargs)

Overloaded function.

1. design_strategy(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions, strategy: pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum) -> None

C++: protocols::antibody::design::CDRSeqDesignOptions::design_strategy(enum protocols::antibody::design::SeqDesignStrategyEnum) –> void

2. design_strategy(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) -> pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum

C++: protocols::antibody::design::CDRSeqDesignOptions::design_strategy() const –> enum protocols::antibody::design::SeqDesignStrategyEnum

disallow_aa(*args, **kwargs)

Overloaded function.

1. disallow_aa(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions, disallowed: pyrosetta.rosetta.utility.vector1_core_chemical_AA) -> None

C++: protocols::antibody::design::CDRSeqDesignOptions::disallow_aa(const class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> > &) –> void

2. disallow_aa(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) -> pyrosetta.rosetta.utility.vector1_core_chemical_AA

C++: protocols::antibody::design::CDRSeqDesignOptions::disallow_aa() const –> class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> >

fallback(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) → bool

C++: protocols::antibody::design::CDRSeqDesignOptions::fallback() const –> bool

fallback_strategy(*args, **kwargs)

Overloaded function.

1. fallback_strategy(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions, strategy: pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum) -> None

Set the fallback strategy - which will be used if using a profile-based primary strategy, and there is not enough data

C++: protocols::antibody::design::CDRSeqDesignOptions::fallback_strategy(enum protocols::antibody::design::SeqDesignStrategyEnum) –> void

2. fallback_strategy(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) -> pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum

C++: protocols::antibody::design::CDRSeqDesignOptions::fallback_strategy() const –> enum protocols::antibody::design::SeqDesignStrategyEnum

set_cdr(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None

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

set_defaults(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions) → None

C++: protocols::antibody::design::CDRSeqDesignOptions::set_defaults() –> void

class pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser, : pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser) → pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser

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

clone(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser) → pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser

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

parse_default_and_user_options(*args, **kwargs)

Overloaded function.

1. parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

Parse default_instructions (mainly used for AbDesign) then parse user file

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

2. parse_default_and_user_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

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

parse_options(*args, **kwargs)

Overloaded function.

1. parse_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, filename: str) -> pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptions

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

2. parse_options(self: pyrosetta.rosetta.protocols.antibody.design.CDRSeqDesignOptionsParser, filename: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

ALL CDRs

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

class pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler

Bases: pybind11_object

Basic Class that can run modeling for various protocols. Does not do any design. Setup design TF via AntibodySeqDesignTFCreator.

ab_dock_chains(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, ab_dock_chains: str) → None

Set the ab_dock chains, which will be used for any docking or minimization on the jump. (LH_A, L_H, etc. - A for antigen)

C++: protocols::antibody::design::GeneralAntibodyModeler::ab_dock_chains(std::string) –> void

apply_A_LH_foldtree(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None

Applies a docking foldtree.. Forked from AbInfo - Its version uses hardcoded order of the PDB. However, this calls docking FT, which is hard coded as well for now.

Fix Me.

C++: protocols::antibody::design::GeneralAntibodyModeler::apply_A_LH_foldtree(class core::pose::Pose &) const –> void

assign(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, : pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) → pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler

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

backrub_cdrs(*args, **kwargs)

Overloaded function.

1. backrub_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. backrub_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool) -> None

3. backrub_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool) -> None

Run the BackrubProtocol on the CDRs. Control backrub through cmd-line.

C++: protocols::antibody::design::GeneralAntibodyModeler::backrub_cdrs(class core::pose::Pose &, bool, bool) const –> void

cdr_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, overhang: int) → None

How many residues on either side of the CDR to include in CDR - modeling? (Default is 0)

C++: protocols::antibody::design::GeneralAntibodyModeler::cdr_overhang(const enum protocols::antibody::CDRNameEnum, const unsigned long) –> void

clone(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) → pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler

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

dock_high_res(*args, **kwargs)

Overloaded function.

1. dock_high_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. dock_high_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, first_cycle: int) -> None

3. dock_high_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, first_cycle: int, second_cycle: int) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::dock_high_res(class core::pose::Pose &, unsigned long, unsigned long) const –> void

dock_low_res(*args, **kwargs)

Overloaded function.

1. dock_low_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. dock_low_res(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, pack_interface: bool) -> None

Dock the antibody. Using A for designation of Antigen chains. Not full antigen chains. (L_A, LH_A, L_H, etc.)

C++: protocols::antibody::design::GeneralAntibodyModeler::dock_low_res(class core::pose::Pose &, bool) const –> void

extend_CDR(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None

Randomizes the dihedrals of the CDR.

C++: protocols::antibody::design::GeneralAntibodyModeler::extend_CDR(class core::pose::Pose &, enum protocols::antibody::CDRNameEnum) const –> void

get_cdr_loop_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → pyrosetta.rosetta.protocols.loops.Loop

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdr_loop_with_overhang(const class core::pose::Pose &, enum protocols::antibody::CDRNameEnum) const –> class protocols::loops::Loop

get_cdr_loops(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops

Get CDR loops with cutpoint in the middle.

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdr_loops(const class core::pose::Pose &) const –> class std::shared_ptr<class protocols::loops::Loops>

get_cdr_loops_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.protocols.loops.Loops

Get CDR loops with set overhang with cutpoint at the stop position +1.

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdr_loops_with_overhang(const class core::pose::Pose &) const –> class std::shared_ptr<class protocols::loops::Loops>

get_cdrs_movemap_with_overhang(*args, **kwargs)

Overloaded function.

1. get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.MoveMap

2. get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

3. get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool, min_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

4. get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool, min_sc: bool, include_neighbor_sc: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

5. get_cdrs_movemap_with_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_bb: bool, min_sc: bool, include_neighbor_sc: bool, include_neighbor_bb: bool) -> pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::design::GeneralAntibodyModeler::get_cdrs_movemap_with_overhang(class core::pose::Pose &, bool, bool, bool, bool) const –> class std::shared_ptr<class core::kinematics::MoveMap>

get_dock_chains(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) → str

C++: protocols::antibody::design::GeneralAntibodyModeler::get_dock_chains() const –> std::string

get_movemap_from_task(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.kinematics.MoveMap

C++: protocols::antibody::design::GeneralAntibodyModeler::get_movemap_from_task(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::PackerTask>) const –> class std::shared_ptr<class core::kinematics::MoveMap>

interface_detection_dis(*args, **kwargs)

Overloaded function.

1. interface_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, interface_distance: float) -> None

Set a value for interface detection across the class.

C++: protocols::antibody::design::GeneralAntibodyModeler::interface_detection_dis(double) –> void

2. interface_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) -> float

C++: protocols::antibody::design::GeneralAntibodyModeler::interface_detection_dis() const –> double

minimize_cdrs(*args, **kwargs)

Overloaded function.

1. minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool) -> None

3. minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool) -> None

4. minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool, min_interface: bool) -> None

5. minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool, min_interface: bool, cartmin: bool) -> None

6. minimize_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_sc: bool, include_neighbor_sc: bool, min_interface: bool, cartmin: bool, use_talaris_cartmin: bool) -> None

Vanilla minimizer using dfpmin_armijo_nonmonotone at .001 tolerance (or lfbgs for cartmin).

C++: protocols::antibody::design::GeneralAntibodyModeler::minimize_cdrs(class core::pose::Pose &, bool, bool, bool, bool, bool) const –> void

minimize_interface(*args, **kwargs)

Overloaded function.

1. minimize_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. minimize_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_interface_sc: bool) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::minimize_interface(class core::pose::Pose &, bool) const –> void

neighbor_detection_dis(*args, **kwargs)

Overloaded function.

1. neighbor_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, neighbor_distance: float) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::neighbor_detection_dis(double) –> void

2. neighbor_detection_dis(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) -> float

C++: protocols::antibody::design::GeneralAntibodyModeler::neighbor_detection_dis() const –> double

relax_cdrs(*args, **kwargs)

Overloaded function.

1. relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool) -> None

3. relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool) -> None

4. relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool, min_interface: bool) -> None

5. relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool, min_interface: bool, dualspace: bool) -> None

6. relax_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool, starting_coordinate_constraints: bool, min_interface: bool, dualspace: bool, repeats: int) -> None

Relax CDRs using FastRelax. CentroidRelax unfortunately does not work well. Perhaps with centroid rotamers..

Cluster Constraints should already be set. Optionally use start_coordinate constraints. All coordinate constraints on the pose will then be removed.

C++: protocols::antibody::design::GeneralAntibodyModeler::relax_cdrs(class core::pose::Pose &, bool, bool, bool, bool, unsigned long) const –> void

relax_interface(*args, **kwargs)

Overloaded function.

1. relax_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. relax_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, min_interface_sc: bool) -> None

C++: protocols::antibody::design::GeneralAntibodyModeler::relax_interface(class core::pose::Pose &, bool) const –> void

repack_antibody_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None

Repack the interface between antibody and antigen, but only pack antibody.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_antibody_interface(class core::pose::Pose &) const –> void

repack_antigen_ab_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None

Repack the interface between Antibody and Antigen.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_antigen_ab_interface(class core::pose::Pose &) const –> void

repack_antigen_interface(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) → None

Repack the interface between antibody and antigen, but only pack antigen.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_antigen_interface(class core::pose::Pose &) const –> void

repack_cdrs(*args, **kwargs)

Overloaded function.

1. repack_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. repack_cdrs(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, pose: pyrosetta.rosetta.core.pose.Pose, include_neighbor_sc: bool) -> None

Repack the CDRs given. Nothing special.

C++: protocols::antibody::design::GeneralAntibodyModeler::repack_cdrs(class core::pose::Pose &, bool) –> void

reset_task_factory(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler) → None

C++: protocols::antibody::design::GeneralAntibodyModeler::reset_task_factory() –> void

set_cdr(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, setting: bool) → None

Set to model CDRs. Default is all of them false.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdr(const enum protocols::antibody::CDRNameEnum, bool) –> void

set_cdr_only(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, setting: bool) → None

Set to model only one cdr, or all others but one.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdr_only(const enum protocols::antibody::CDRNameEnum, bool) –> void

set_cdr_range(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, cdr_start: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, cdr_end: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, setting: bool) → None

Set a range of CDRs.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdr_range(const enum protocols::antibody::CDRNameEnum, const enum protocols::antibody::CDRNameEnum, bool) –> void

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

C++: protocols::antibody::design::GeneralAntibodyModeler::set_cdrs(class utility::vector1<bool, class std::allocator<bool> >) –> void

set_dock_high_res_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::antibody::design::GeneralAntibodyModeler::set_dock_high_res_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_dock_low_res_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::antibody::design::GeneralAntibodyModeler::set_dock_low_res_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_overhang(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, overhang: int) → None

Set the overhang for all cdrs. (Default is 0)

C++: protocols::antibody::design::GeneralAntibodyModeler::set_overhang(const unsigned long) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::antibody::design::GeneralAntibodyModeler::set_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_scorefunction_min(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Set scorefunction used for bb minimization.

C++: protocols::antibody::design::GeneralAntibodyModeler::set_scorefunction_min(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.antibody.design.GeneralAntibodyModeler, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

C++: protocols::antibody::design::GeneralAntibodyModeler::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> void

class pyrosetta.rosetta.protocols.antibody.design.MinTypeEnum

Bases: pybind11_object

Members:

relax

centroid_relax

minimize

minimize_cartesian

dualspace

repack

backrub_protocol

no_min

MinTypeEnum_total

MinTypeEnum_total = <MinTypeEnum.no_min: 8>

backrub_protocol = <MinTypeEnum.backrub_protocol: 7>

centroid_relax = <MinTypeEnum.centroid_relax: 2>

dualspace = <MinTypeEnum.dualspace: 5>

minimize = <MinTypeEnum.minimize: 3>

minimize_cartesian = <MinTypeEnum.minimize_cartesian: 4>

property name

no_min = <MinTypeEnum.no_min: 8>

relax = <MinTypeEnum.relax: 1>

repack = <MinTypeEnum.repack: 6>

property value

class pyrosetta.rosetta.protocols.antibody.design.MutantPosition

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.antibody.design.MutantPosition, : pyrosetta.rosetta.protocols.antibody.design.MutantPosition) → pyrosetta.rosetta.protocols.antibody.design.MutantPosition

C++: protocols::antibody::design::MutantPosition::operator=(const struct protocols::antibody::design::MutantPosition &) –> struct protocols::antibody::design::MutantPosition &

property mutants_allowed_

property numbering_scheme_

property pdb_position_

class pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster

Bases: Mover

Mutates framework positions to what is needed for a particular cluster if that cluster has needed mutations.

Will use clusters from pose data cache if there, otherwise, will use clusters set from AntibodyInfo.

Use set_cdr or set_cdrs to limit to a particular CDR or set of CDRs.

apply(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::antibody::design::MutateFrameworkForCluster::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, : pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster) → pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster

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

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>

framework_dependant_clusters(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster) → pyrosetta.rosetta.utility.vector1_protocols_antibody_clusters_CDRClusterEnum

Get all framework dependant clusters in list

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_clusters() –> class utility::vector1<enum protocols::antibody::clusters::CDRClusterEnum, class std::allocator<enum protocols::antibody::clusters::CDRClusterEnum> >

framework_dependant_mutations(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum, resnum: int) → pyrosetta.rosetta.utility.vector1_bool

Get all framework mutations for a particular framework dependent position, regardless of whether that cluster is in the pose.

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_mutations(const class core::pose::Pose &, const enum protocols::antibody::clusters::CDRClusterEnum, const unsigned long) –> class utility::vector1<bool, class std::allocator<bool> >

framework_dependant_positions(*args, **kwargs)

Overloaded function.

1. framework_dependant_positions(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.utility.vector1_bool

Get all framework positions that would be required by clusters regardless of whether that cluster is in the pose.

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_positions(const class core::pose::Pose &) –> class utility::vector1<bool, class std::allocator<bool> >

2. framework_dependant_positions(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose, cluster: pyrosetta.rosetta.protocols.antibody.clusters.CDRClusterEnum) -> pyrosetta.rosetta.utility.vector1_bool

Get all framework positions that would be required by a cluster regardless of whether that cluster is in the pose.

C++: protocols::antibody::design::MutateFrameworkForCluster::framework_dependant_positions(const class core::pose::Pose &, const enum protocols::antibody::clusters::CDRClusterEnum) –> class utility::vector1<bool, class std::allocator<bool> >

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

C++: protocols::antibody::design::MutateFrameworkForCluster::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_data(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster) → pyrosetta.rosetta.std.map_protocols_antibody_clusters_CDRClusterEnum_utility_vector1_protocols_antibody_design_MutantPosition_std_allocator_protocols_antibody_design_MutantPosition_t_std_allocator_std_pair_const_protocols_antibody_clusters_CDRClusterEnum_utility_vector1_protocols_antibody_design_MutantPosition_std_allocator_protocols_antibody_design_MutantPosition_t

Get data used to do the design.

C++: protocols::antibody::design::MutateFrameworkForCluster::get_data() –> class std::map<enum protocols::antibody::clusters::CDRClusterEnum, class utility::vector1<struct protocols::antibody::design::MutantPosition, class std::allocator<struct protocols::antibody::design::MutantPosition> >, struct std::less<enum protocols::antibody::clusters::CDRClusterEnum>, class std::allocator<struct std::pair<const enum protocols::antibody::clusters::CDRClusterEnum, class utility::vector1<struct protocols::antibody::design::MutantPosition, class std::allocator<struct protocols::antibody::design::MutantPosition> > > > >

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.design.MutateFrameworkForCluster) → str

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

has_framework_dependant_cluster(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → bool

C++: protocols::antibody::design::MutateFrameworkForCluster::has_framework_dependant_cluster(const class core::pose::Pose &, const enum protocols::antibody::CDRNameEnum) –> bool

has_framework_dependant_clusters(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pose: pyrosetta.rosetta.core.pose.Pose) → bool

//////// Helper functions //////////////

C++: protocols::antibody::design::MutateFrameworkForCluster::has_framework_dependant_clusters(const class core::pose::Pose &) –> bool

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.antibody.design.MutateFrameworkForCluster, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None

C++: protocols::antibody::design::MutateFrameworkForCluster::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.design.MutateFrameworkForCluster, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

C++: protocols::antibody::design::MutateFrameworkForCluster::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_cdr_only(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None

C++: protocols::antibody::design::MutateFrameworkForCluster::set_cdr_only(const enum protocols::antibody::CDRNameEnum &) –> void

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

C++: protocols::antibody::design::MutateFrameworkForCluster::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_custom_data(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, mutant_info: pyrosetta.rosetta.std.map_protocols_antibody_clusters_CDRClusterEnum_utility_vector1_protocols_antibody_design_MutantPosition_std_allocator_protocols_antibody_design_MutantPosition_t_std_allocator_std_pair_const_protocols_antibody_clusters_CDRClusterEnum_utility_vector1_protocols_antibody_design_MutantPosition_std_allocator_protocols_antibody_design_MutantPosition_t) → None

Set custom data instead of loading it from the database.

C++: protocols::antibody::design::MutateFrameworkForCluster::set_custom_data(const class std::map<enum protocols::antibody::clusters::CDRClusterEnum, class utility::vector1<struct protocols::antibody::design::MutantPosition, class std::allocator<struct protocols::antibody::design::MutantPosition> >, struct std::less<enum protocols::antibody::clusters::CDRClusterEnum>, class std::allocator<struct std::pair<const enum protocols::antibody::clusters::CDRClusterEnum, class utility::vector1<struct protocols::antibody::design::MutantPosition, class std::allocator<struct protocols::antibody::design::MutantPosition> > > > > &) –> 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_shell(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForCluster, pack_shell: float) → None

Set the distance for the packing shell.

C++: protocols::antibody::design::MutateFrameworkForCluster::set_pack_shell(const double) –> void

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

C++: protocols::antibody::design::MutateFrameworkForCluster::set_scorefxn(class std::shared_ptr<const 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.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None

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

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(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.

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

Set the ‘type’ string

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

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

Bases: MoverCreator

assign(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForClusterCreator, : pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForClusterCreator) → pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForClusterCreator

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

create_mover(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForClusterCreator) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::antibody::design::MutateFrameworkForClusterCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.antibody.design.MutateFrameworkForClusterCreator) → str

C++: protocols::antibody::design::MutateFrameworkForClusterCreator::keyname() const –> std::string

static mover_name() → str

C++: protocols::antibody::design::MutateFrameworkForClusterCreator::mover_name() –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.moves.MoverCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the schema for the Mover that this Creator is responsible for

C++: protocols::moves::MoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq

Bases: CacheableData

Class that keeps track of the ‘native’ sequence during design. Native means that no design has occured. Used for conservative base design to keep it from hopping around residue types.

assign(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, : pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq) → pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq

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

clone(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: protocols::antibody::design::NativeAntibodySeq::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get_cdr_sequence(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq) → pyrosetta.rosetta.std.map_protocols_antibody_CDRNameEnum_utility_vector1_core_chemical_AA_std_allocator_core_chemical_AA_t_std_allocator_std_pair_const_protocols_antibody_CDRNameEnum_utility_vector1_core_chemical_AA_std_allocator_core_chemical_AA_t

Get a map of each native CDR sequence

C++: protocols::antibody::design::NativeAntibodySeq::get_cdr_sequence() const –> const class std::map<enum protocols::antibody::CDRNameEnum, class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> >, struct std::less<enum protocols::antibody::CDRNameEnum>, class std::allocator<struct std::pair<const enum protocols::antibody::CDRNameEnum, class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> > > > > &

get_full_sequence(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq) → pyrosetta.rosetta.std.map_std_string_core_chemical_AA

Get a map of PDBInfo residues to AA residues as the sequence

C++: protocols::antibody::design::NativeAntibodySeq::get_full_sequence() const –> const class std::map<std::string, enum core::chemical::AA, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, enum core::chemical::AA> > > &

get_native_sequence_matching_current_length(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str

Get the full pose sequence, accounting for length changes to the pose.

C++: protocols::antibody::design::NativeAntibodySeq::get_native_sequence_matching_current_length(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) const –> std::string

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData

C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t

C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

set_from_cdr(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum) → None

Sets the sequence from the CDR of the PDB into this class and into the pose.

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

set_sequence(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → None

Sets the sequence from the PDB into this class and into the pose.

C++: protocols::antibody::design::NativeAntibodySeq::set_sequence(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> void

set_to_pose(self: pyrosetta.rosetta.protocols.antibody.design.NativeAntibodySeq, pose: pyrosetta.rosetta.core.pose.Pose) → None

Set this class to the pose datacache.

C++: protocols::antibody::design::NativeAntibodySeq::set_to_pose(class core::pose::Pose &) –> void

class pyrosetta.rosetta.protocols.antibody.design.PDBNumbering

Bases: pybind11_object

Move this somewhere in pose or pose_selection. PDBInfo’s ResidueKey should be public and passed around in the first place.

Super-basic numbering struct.

property chain

property icode

property resnum

class pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector

Bases: ResidueSelector

A selector which uses the protocols::antibody::design::get_resnums_from_strings_with_ranges() approach.

apply(self: pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_bool

“Apply” function.

Return the set subset.

C++: protocols::antibody::design::ResnumFromStringsWithRangesSelector::apply(const class core::pose::Pose &) const –> class utility::vector1<bool, class std::allocator<bool> >

assign(self: pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector, : pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector) → pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector

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

static class_name() → str

Get the mover class name.

C++: protocols::antibody::design::ResnumFromStringsWithRangesSelector::class_name() –> std::string

clone(self: pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Clone operator.

Copy the current object (creating the copy on the heap) and return an owning pointer to the copy. All ResidueSelectors must implement this.

C++: protocols::antibody::design::ResnumFromStringsWithRangesSelector::clone() const –> class std::shared_ptr<class core::select::residue_selector::ResidueSelector>

get_name(self: pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector) → str

Get the mover class name.

C++: protocols::antibody::design::ResnumFromStringsWithRangesSelector::get_name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.antibody.design.ResnumFromStringsWithRangesSelector, tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

XML parse.

Parse RosettaScripts tags and set up this mover.

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

provide_citation_info(self: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, : 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 residue selectors wishing to provide citation information.

C++: core::select::residue_selector::ResidueSelector::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

Provide XSD information, enabling mechanical validation of input XML.

C++: protocols::antibody::design::ResnumFromStringsWithRangesSelector::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

selection_positions(self: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long

Calls apply and returns the Rosetta numbering corresponding to the selected residues

C++: core::select::residue_selector::ResidueSelector::selection_positions(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

class pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum

Bases: pybind11_object

Members:

seq_design_profiles

seq_design_conservative

seq_design_profile_sets

seq_design_profile_sets_combined

seq_design_basic

seq_design_none

SeqDesignStrategyEnum_total

SeqDesignStrategyEnum_total = <SeqDesignStrategyEnum.seq_design_none: 6>

property name

seq_design_basic = <SeqDesignStrategyEnum.seq_design_basic: 5>

seq_design_conservative = <SeqDesignStrategyEnum.seq_design_conservative: 2>

seq_design_none = <SeqDesignStrategyEnum.seq_design_none: 6>

seq_design_profile_sets = <SeqDesignStrategyEnum.seq_design_profile_sets: 3>

seq_design_profile_sets_combined = <SeqDesignStrategyEnum.seq_design_profile_sets_combined: 4>

seq_design_profiles = <SeqDesignStrategyEnum.seq_design_profiles: 1>

property value

pyrosetta.rosetta.protocols.antibody.design.add_loops_from_bool_vector(*args, **kwargs)

Overloaded function.

1. add_loops_from_bool_vector(loops: pyrosetta.rosetta.protocols.loops.Loops, residues: pyrosetta.rosetta.utility.vector1_bool) -> None

2. add_loops_from_bool_vector(loops: pyrosetta.rosetta.protocols.loops.Loops, residues: pyrosetta.rosetta.utility.vector1_bool, add_cutpoints: bool) -> None

C++: protocols::antibody::design::add_loops_from_bool_vector(class protocols::loops::Loops &, class utility::vector1<bool, class std::allocator<bool> >, bool) –> void

pyrosetta.rosetta.protocols.antibody.design.attributes_for_get_ab_design_global_scorefxn(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

adds the required attribute to the AttributeList for XMLSchema generation

C++: protocols::antibody::design::attributes_for_get_ab_design_global_scorefxn(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.antibody.design.attributes_for_get_ab_design_min_scorefxn(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

adds the required attribute to the AttributeList for XMLSchema generation

C++: protocols::antibody::design::attributes_for_get_ab_design_min_scorefxn(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.antibody.design.check_cb(*args, **kwargs)

Overloaded function.

1. check_cb(pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_bool) -> Tuple[bool, int]

Check for severe peptide bond issues. Return pair of chainbreak, and position of wonky peptide bond

C++: protocols::antibody::design::check_cb(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) –> struct std::pair<bool, unsigned long>

2. check_cb(pose: pyrosetta.rosetta.core.pose.Pose, loops: pyrosetta.rosetta.protocols.loops.Loops) -> Tuple[bool, int]

Check for severe peptide bond issues. Return pair of chainbreak, and position of wonky peptide bond

C++: protocols::antibody::design::check_cb(const class core::pose::Pose &, const class protocols::loops::Loops &) –> struct std::pair<bool, unsigned long>

pyrosetta.rosetta.protocols.antibody.design.deep_copy(: protocols::antibody::design::CDRSeqDesignOptions) → protocols::antibody::design::CDRSeqDesignOptions

C++: protocols::antibody::design::deep_copy(const class protocols::antibody::design::CDRSeqDesignOptions &) –> class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>

pyrosetta.rosetta.protocols.antibody.design.design_protocol_to_enum(design_type: str) → pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum

C++: protocols::antibody::design::design_protocol_to_enum(const std::string &) –> enum protocols::antibody::design::AntibodyDesignProtocolEnum

pyrosetta.rosetta.protocols.antibody.design.design_protocol_to_string(design_type: pyrosetta.rosetta.protocols.antibody.design.AntibodyDesignProtocolEnum) → str

C++: protocols::antibody::design::design_protocol_to_string(const enum protocols::antibody::design::AntibodyDesignProtocolEnum) –> std::string

pyrosetta.rosetta.protocols.antibody.design.disable_conserved_framework_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design for conserved framework positions.

TODO: Needs to be expanded to read positions from database.

C++: protocols::antibody::design::disable_conserved_framework_positions(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_antigen(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of the antigen residues

C++: protocols::antibody::design::disable_design_antigen(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_cdr(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Get a Restrict operation to turn OFF design for particular CDRs.

C++: protocols::antibody::design::disable_design_cdr(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, enum protocols::antibody::CDRNameEnum, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_cdrs(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Get a Restrict operation to turn OFF design for all CDRs.

C++: protocols::antibody::design::disable_design_cdrs(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_framework(*args, **kwargs)

Overloaded function.

1. disable_design_framework(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

2. disable_design_framework(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdr4_as_framework: bool) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of the framework residues

C++: protocols::antibody::design::disable_design_framework(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, bool) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_design_region(*args, **kwargs)

Overloaded function.

1. disable_design_region(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, region: pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

2. disable_design_region(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, region: pyrosetta.rosetta.protocols.antibody.AntibodyRegionEnum, cdr4_as_framework: bool) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of any particular region of the antibody complex.

C++: protocols::antibody::design::disable_design_region(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, enum protocols::antibody::AntibodyRegionEnum, bool) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.disable_h3_stem_positions(*args, **kwargs)

Overloaded function.

1. disable_h3_stem_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

2. disable_h3_stem_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, nter_stem: int) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

3. disable_h3_stem_positions(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, nter_stem: int, cter_stem: int) -> pyrosetta.rosetta.core.pack.task.operation.RestrictResidueToRepacking

Disable design of the first 2 and last 3 residues of the H3 CDR (North CDR definitions - kink determinants)

C++: protocols::antibody::design::disable_h3_stem_positions(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, unsigned long, unsigned long) –> class std::shared_ptr<class core::pack::task::operation::RestrictResidueToRepacking>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_dock_high_scorefxn() → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::antibody::design::get_ab_design_dock_high_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_dock_low_scorefxn() → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::antibody::design::get_ab_design_dock_low_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_global_scorefxn(*args, **kwargs)

Overloaded function.

1. get_ab_design_global_scorefxn() -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::antibody::design::get_ab_design_global_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

2. get_ab_design_global_scorefxn(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Get Global Scorefxn from RS; XSD companion function: attributes_for_get_ab_design_global_scorefxn

C++: protocols::antibody::design::get_ab_design_global_scorefxn(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_ab_design_min_scorefxn(*args, **kwargs)

Overloaded function.

1. get_ab_design_min_scorefxn() -> pyrosetta.rosetta.core.scoring.ScoreFunction

XSD companion function: attributes_for_get_ab_design_min_scorefxn

C++: protocols::antibody::design::get_ab_design_min_scorefxn() –> class std::shared_ptr<class core::scoring::ScoreFunction>

2. get_ab_design_min_scorefxn(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::antibody::design::get_ab_design_min_scorefxn(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.protocols.antibody.design.get_all_graft_permutations(permutations: pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t, totals: pyrosetta.rosetta.utility.vector1_unsigned_long, n: int) → pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t

Gets all possible graft permutations.

all_permutations is a list of vectors corresponding to cdrs_to_design vector. Essentially, each inner index describes a position in the cdr_set. Indexes correspond to CDRNameEnum, and whose values correspond to the cdr_set index. If the value is 0, it means no cdr in set. Example: <1, 0, 1, 1, 1, 1>. This is a possible combination to try graft, the second CDR, H2 is not part of the combination.

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

pyrosetta.rosetta.protocols.antibody.design.get_cdr_set_options(*args, **kwargs)

Overloaded function.

1. get_cdr_set_options() -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

Get default options

C++: protocols::antibody::design::get_cdr_set_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::CDRSetOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::CDRSetOptions> > >

2. get_cdr_set_options(instruction_file: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_CDRSetOptions_t

Get options from an instruction file

C++: protocols::antibody::design::get_cdr_set_options(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.design.get_cluster_profile_probability_data(*args, **kwargs)

Overloaded function.

1. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool) -> 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

2. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int) -> 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

3. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool) -> 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

4. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool) -> 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

5. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, cdrs: pyrosetta.rosetta.utility.vector1_bool, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool, ignore_light_chain_: bool) -> 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

Get probability data for a given set of CDRs. Will fill in the no_data_cdrs;

C++: protocols::antibody::design::get_cluster_profile_probability_data(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long, const bool, const bool, const bool) –> 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> > > > > >

6. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool) -> 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

7. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int) -> 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

8. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool) -> 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

9. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool) -> 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

10. get_cluster_profile_probability_data(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, seq_design_options: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t, no_data_cdrs: pyrosetta.rosetta.utility.vector1_bool, prob_cutoff: int, use_outliers: bool, force_north_db: bool, ignore_light_chain_: bool) -> 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

C++: protocols::antibody::design::get_cluster_profile_probability_data(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, 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> > > &, class utility::vector1<bool, class std::allocator<bool> > &, const unsigned long, const bool, const bool, const bool) –> 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> > > > > >

pyrosetta.rosetta.protocols.antibody.design.get_dock_chains_from_ab_dock_chains(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, ab_dock_chains: str) → str

Convert an ab_dock_chain (L_H/ LH_A, etc. to the full dock chain string)

C++: protocols::antibody::design::get_dock_chains_from_ab_dock_chains(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const std::string &) –> std::string

pyrosetta.rosetta.protocols.antibody.design.get_graft_design_options(*args, **kwargs)

Overloaded function.

1. get_graft_design_options() -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t

Get default options

C++: protocols::antibody::design::get_graft_design_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions> > >

2. get_graft_design_options(instruction_file: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRGraftDesignOptions_t

Get options from an instruction file

C++: protocols::antibody::design::get_graft_design_options(std::string) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRGraftDesignOptions> > >

pyrosetta.rosetta.protocols.antibody.design.get_native_sequence(pose: pyrosetta.rosetta.core.pose.Pose, ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo) → str

C++: protocols::antibody::design::get_native_sequence(const class core::pose::Pose &, const class protocols::antibody::AntibodyInfo &) –> std::string

pyrosetta.rosetta.protocols.antibody.design.get_pdb_numbering_from_single_string(pdb_residue: str) → pyrosetta.rosetta.protocols.antibody.design.PDBNumbering

Get the PDBNumbering from strings such as: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_pdb_numbering_from_single_string(const std::string &) –> struct protocols::antibody::design::PDBNumbering

pyrosetta.rosetta.protocols.antibody.design.get_pdb_numbering_from_strings(pdb_residues: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_protocols_antibody_design_PDBNumbering

Get PDBNumbering from a vector of strings:

Example: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_pdb_numbering_from_strings(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> class utility::vector1<struct protocols::antibody::design::PDBNumbering, class std::allocator<struct protocols::antibody::design::PDBNumbering> >

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_pdb_numbering(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residues: pyrosetta.rosetta.utility.vector1_protocols_antibody_design_PDBNumbering) → pyrosetta.rosetta.utility.vector1_bool

Get a boolean vector from a string of PDBNumbering. No error checking. Use with caution.

C++: protocols::antibody::design::get_resnum_from_pdb_numbering(const class core::pose::Pose &, const class utility::vector1<struct protocols::antibody::design::PDBNumbering, class std::allocator<struct protocols::antibody::design::PDBNumbering> > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_single_string(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residue: str) → int

Get a resnum from strings such as: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_resnum_from_single_string(const class core::pose::Pose &, const std::string &) –> unsigned long

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_single_string_w_landmark(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, pose: pyrosetta.rosetta.core.pose.Pose, pdb_residue: str, scheme: pyrosetta.rosetta.protocols.antibody.AntibodyNumberingSchemeEnum) → int

Get a resnum using the PDBLandmark from strings such as: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_resnum_from_single_string_w_landmark(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const class core::pose::Pose &, const std::string &, const enum protocols::antibody::AntibodyNumberingSchemeEnum &) –> unsigned long

pyrosetta.rosetta.protocols.antibody.design.get_resnum_from_strings(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residues: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_bool

get a boolean vector from a vector of strings:

Example: 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code.

C++: protocols::antibody::design::get_resnum_from_strings(const class core::pose::Pose &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.design.get_resnums_from_strings_with_ranges(pose: pyrosetta.rosetta.core.pose.Pose, pdb_residues: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_bool

Get a boolean vector of resnums with ranges, where a - indicates range.

Parses strings for PDB resnums such as 1A, 1A:I, 1:A:~, 1:A:I with A being chain A and I being an insertion code. Example: 1A-10A or 1A-10A:I

C++: protocols::antibody::design::get_resnums_from_strings_with_ranges(const class core::pose::Pose &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> class utility::vector1<bool, class std::allocator<bool> >

pyrosetta.rosetta.protocols.antibody.design.get_seq_design_options(*args, **kwargs)

Overloaded function.

1. get_seq_design_options() -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

Get default options

C++: protocols::antibody::design::get_seq_design_options() –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >

2. get_seq_design_options(instruction_file: str) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_antibody_design_CDRSeqDesignOptions_t

Get options from an instruction file

C++: protocols::antibody::design::get_seq_design_options(std::string) –> class utility::vector1<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions>, class std::allocator<class std::shared_ptr<class protocols::antibody::design::CDRSeqDesignOptions> > >

pyrosetta.rosetta.protocols.antibody.design.has_native_sequence(pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::antibody::design::has_native_sequence(const class core::pose::Pose &) –> bool

pyrosetta.rosetta.protocols.antibody.design.insert_cdr_into_antibody(*args, **kwargs)

Overloaded function.

1. insert_cdr_into_antibody(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, cdr_piece: pyrosetta.rosetta.core.pose.Pose) -> None

2. insert_cdr_into_antibody(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose, cdr_piece: pyrosetta.rosetta.core.pose.Pose, overhang: int) -> None

Use insert_pose_into_pose to replace the cdr_piece with the current antibody’s CDR. No modeling or superposition. For that, use protocols/grafting

C++: protocols::antibody::design::insert_cdr_into_antibody(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, const enum protocols::antibody::CDRNameEnum, class core::pose::Pose &, class core::pose::Pose &, unsigned long) –> void

pyrosetta.rosetta.protocols.antibody.design.seq_design_strategy_to_enum(strategy: str) → pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum

C++: protocols::antibody::design::seq_design_strategy_to_enum(const std::string &) –> enum protocols::antibody::design::SeqDesignStrategyEnum

pyrosetta.rosetta.protocols.antibody.design.seq_design_strategy_to_string(strategy: pyrosetta.rosetta.protocols.antibody.design.SeqDesignStrategyEnum) → str

C++: protocols::antibody::design::seq_design_strategy_to_string(enum protocols::antibody::design::SeqDesignStrategyEnum) –> std::string

pyrosetta.rosetta.protocols.antibody.design.set_native_cdr_sequence(ab_info: pyrosetta.rosetta.protocols.antibody.AntibodyInfo, cdr: pyrosetta.rosetta.protocols.antibody.CDRNameEnum, pose: pyrosetta.rosetta.core.pose.Pose) → None

Set the native CDR sequence into the pose datacache

If none is set in the pose, will add it.

C++: protocols::antibody::design::set_native_cdr_sequence(class std::shared_ptr<const class protocols::antibody::AntibodyInfo>, enum protocols::antibody::CDRNameEnum, class core::pose::Pose &) –> void