dna¶

Bindings for protocols::dna namespace

class pyrosetta.rosetta.protocols.dna.DNABase¶

Bases: pybind11_object

alpha(*args, **kwargs)¶

Overloaded function.

alpha(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::alpha() const –> double

alpha(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::alpha(double) –> void

amplitude(*args, **kwargs)¶

Overloaded function.

amplitude(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::amplitude() const –> double

amplitude(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::amplitude(double) –> void

beta(*args, **kwargs)¶

Overloaded function.

beta(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::beta() const –> double

beta(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::beta(double) –> void

chi(*args, **kwargs)¶

Overloaded function.

chi(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::chi() const –> double

chi(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::chi(double) –> void

delta(*args, **kwargs)¶

Overloaded function.

delta(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::delta() const –> double

delta(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::delta(double) –> void

epsilon(*args, **kwargs)¶

Overloaded function.

epsilon(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::epsilon() const –> double

epsilon(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::epsilon(double) –> void

gamma(*args, **kwargs)¶

Overloaded function.

gamma(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::gamma() const –> double

gamma(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::gamma(double) –> void

pseudorotation(*args, **kwargs)¶

Overloaded function.

pseudorotation(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::pseudorotation() const –> double

pseudorotation(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::pseudorotation(double) –> void

zeta(*args, **kwargs)¶

Overloaded function.

zeta(self: pyrosetta.rosetta.protocols.dna.DNABase) -> float

C++: protocols::dna::DNABase::zeta() const –> double

zeta(self: pyrosetta.rosetta.protocols.dna.DNABase, in_value: float) -> None

C++: protocols::dna::DNABase::zeta(double) –> void

class pyrosetta.rosetta.protocols.dna.DNABasepair¶

Bases: pybind11_object

buckle(*args, **kwargs)¶

Overloaded function.

buckle(self: pyrosetta.rosetta.protocols.dna.DNABasepair) -> float

C++: protocols::dna::DNABasepair::buckle() const –> double

buckle(self: pyrosetta.rosetta.protocols.dna.DNABasepair, in_value: float) -> None

C++: protocols::dna::DNABasepair::buckle(double) –> void

opening(*args, **kwargs)¶

Overloaded function.

opening(self: pyrosetta.rosetta.protocols.dna.DNABasepair) -> float

C++: protocols::dna::DNABasepair::opening() const –> double

opening(self: pyrosetta.rosetta.protocols.dna.DNABasepair, in_value: float) -> None

C++: protocols::dna::DNABasepair::opening(double) –> void

propeller(*args, **kwargs)¶

Overloaded function.

propeller(self: pyrosetta.rosetta.protocols.dna.DNABasepair) -> float

C++: protocols::dna::DNABasepair::propeller() const –> double

propeller(self: pyrosetta.rosetta.protocols.dna.DNABasepair, in_value: float) -> None

C++: protocols::dna::DNABasepair::propeller(double) –> void

shear(*args, **kwargs)¶

Overloaded function.

shear(self: pyrosetta.rosetta.protocols.dna.DNABasepair) -> float

C++: protocols::dna::DNABasepair::shear() const –> double

shear(self: pyrosetta.rosetta.protocols.dna.DNABasepair, in_value: float) -> None

C++: protocols::dna::DNABasepair::shear(double) –> void

stagger(*args, **kwargs)¶

Overloaded function.

stagger(self: pyrosetta.rosetta.protocols.dna.DNABasepair) -> float

C++: protocols::dna::DNABasepair::stagger() const –> double

stagger(self: pyrosetta.rosetta.protocols.dna.DNABasepair, in_value: float) -> None

C++: protocols::dna::DNABasepair::stagger(double) –> void

stretch(*args, **kwargs)¶

Overloaded function.

stretch(self: pyrosetta.rosetta.protocols.dna.DNABasepair) -> float

C++: protocols::dna::DNABasepair::stretch() const –> double

stretch(self: pyrosetta.rosetta.protocols.dna.DNABasepair, in_value: float) -> None

C++: protocols::dna::DNABasepair::stretch(double) –> void

class pyrosetta.rosetta.protocols.dna.DNABasestep¶

Bases: pybind11_object

rise(*args, **kwargs)¶

Overloaded function.

rise(self: pyrosetta.rosetta.protocols.dna.DNABasestep) -> float

C++: protocols::dna::DNABasestep::rise() const –> double

rise(self: pyrosetta.rosetta.protocols.dna.DNABasestep, in_value: float) -> None

C++: protocols::dna::DNABasestep::rise(double) –> void

roll(*args, **kwargs)¶

Overloaded function.

roll(self: pyrosetta.rosetta.protocols.dna.DNABasestep) -> float

C++: protocols::dna::DNABasestep::roll() const –> double

roll(self: pyrosetta.rosetta.protocols.dna.DNABasestep, in_value: float) -> None

C++: protocols::dna::DNABasestep::roll(double) –> void

shift(*args, **kwargs)¶

Overloaded function.

shift(self: pyrosetta.rosetta.protocols.dna.DNABasestep) -> float

C++: protocols::dna::DNABasestep::shift() const –> double

shift(self: pyrosetta.rosetta.protocols.dna.DNABasestep, in_value: float) -> None

C++: protocols::dna::DNABasestep::shift(double) –> void

slide(*args, **kwargs)¶

Overloaded function.

slide(self: pyrosetta.rosetta.protocols.dna.DNABasestep) -> float

C++: protocols::dna::DNABasestep::slide() const –> double

slide(self: pyrosetta.rosetta.protocols.dna.DNABasestep, in_value: float) -> None

C++: protocols::dna::DNABasestep::slide(double) –> void

tilt(*args, **kwargs)¶

Overloaded function.

tilt(self: pyrosetta.rosetta.protocols.dna.DNABasestep) -> float

C++: protocols::dna::DNABasestep::tilt() const –> double

tilt(self: pyrosetta.rosetta.protocols.dna.DNABasestep, in_value: float) -> None

C++: protocols::dna::DNABasestep::tilt(double) –> void

twist(*args, **kwargs)¶

Overloaded function.

twist(self: pyrosetta.rosetta.protocols.dna.DNABasestep) -> float

C++: protocols::dna::DNABasestep::twist() const –> double

twist(self: pyrosetta.rosetta.protocols.dna.DNABasestep, in_value: float) -> None

C++: protocols::dna::DNABasestep::twist(double) –> void

class pyrosetta.rosetta.protocols.dna.DNAParameters¶

Bases: pybind11_object

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

base(self: pyrosetta.rosetta.protocols.dna.DNAParameters, resid: int) → pyrosetta.rosetta.protocols.dna.DNABase¶: C++: protocols::dna::DNAParameters::base(unsigned long) const –> const class protocols::dna::DNABase &

basepair(self: pyrosetta.rosetta.protocols.dna.DNAParameters, resid: int) → pyrosetta.rosetta.protocols.dna.DNABasepair¶: C++: protocols::dna::DNAParameters::basepair(unsigned long) const –> const class protocols::dna::DNABasepair &

basestep(self: pyrosetta.rosetta.protocols.dna.DNAParameters, resid: int) → pyrosetta.rosetta.protocols.dna.DNABasestep¶: C++: protocols::dna::DNAParameters::basestep(unsigned long) const –> const class protocols::dna::DNABasestep &

calculate(self: pyrosetta.rosetta.protocols.dna.DNAParameters, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::dna::DNAParameters::calculate(const class core::pose::Pose &) –> void

find_partner(self: pyrosetta.rosetta.protocols.dna.DNAParameters, resid: int) → int¶: C++: protocols::dna::DNAParameters::find_partner(unsigned long) const –> unsigned long

is_base_paired(self: pyrosetta.rosetta.protocols.dna.DNAParameters, resid: int) → bool¶: C++: protocols::dna::DNAParameters::is_base_paired(unsigned long) const –> bool

nth_dna_base(self: pyrosetta.rosetta.protocols.dna.DNAParameters, index: int) → int¶: C++: protocols::dna::DNAParameters::nth_dna_base(unsigned long) const –> const unsigned long &

number_of_basepairs(self: pyrosetta.rosetta.protocols.dna.DNAParameters) → int¶: C++: protocols::dna::DNAParameters::number_of_basepairs() –> unsigned long

number_of_bases(self: pyrosetta.rosetta.protocols.dna.DNAParameters) → int¶: C++: protocols::dna::DNAParameters::number_of_bases() –> unsigned long

number_of_basesteps(self: pyrosetta.rosetta.protocols.dna.DNAParameters) → int¶: C++: protocols::dna::DNAParameters::number_of_basesteps() –> unsigned long

random_basepair(self: pyrosetta.rosetta.protocols.dna.DNAParameters) → int¶: C++: protocols::dna::DNAParameters::random_basepair() const –> unsigned long

random_basestep(self: pyrosetta.rosetta.protocols.dna.DNAParameters) → int¶: C++: protocols::dna::DNAParameters::random_basestep() const –> unsigned long

valid_basestep_start(self: pyrosetta.rosetta.protocols.dna.DNAParameters, resid: int) → bool¶: C++: protocols::dna::DNAParameters::valid_basestep_start(unsigned long) const –> bool

class pyrosetta.rosetta.protocols.dna.DesignProteinBackboneAroundDNA¶

Bases: PackRotamersMover

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

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

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

required in the context of the parser/scripting scheme

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

static complex_type_generator_for_pack_rotamers_mover(xsd: utility::tag::XMLSchemaDefinition) → utility::tag::XMLSchemaComplexTypeGenerator¶: C++: protocols::minimization_packing::PackRotamersMover::complex_type_generator_for_pack_rotamers_mover(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

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

required in the context of the parser/scripting scheme

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

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

fpd

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

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

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

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

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

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

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

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

get_name(self: pyrosetta.rosetta.protocols.dna.DesignProteinBackboneAroundDNA) → str¶: C++: protocols::dna::DesignProteinBackboneAroundDNA::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

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

non-const accessor

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

initialize_task_factory_with_operations(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.std.list_std_shared_ptr_core_pack_task_operation_TaskOperation_t) → None¶: C++: protocols::minimization_packing::PackRotamersMover::initialize_task_factory_with_operations(const class std::list<class std::shared_ptr<class core::pack::task::operation::TaskOperation>, class std::allocator<class std::shared_ptr<class core::pack::task::operation::TaskOperation> > > &) –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static list_options_read(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None¶: C++: protocols::minimization_packing::PackRotamersMover::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

static mover_name() → str¶: C++: protocols::dna::DesignProteinBackboneAroundDNA::mover_name() –> std::string

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

nloop(*args, **kwargs)¶

Overloaded function.

nloop(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, nloop_in: int) -> None

C++: protocols::minimization_packing::PackRotamersMover::nloop(unsigned long) –> void

nloop(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> int

C++: protocols::minimization_packing::PackRotamersMover::nloop() const –> unsigned long

parse_my_tag(self: pyrosetta.rosetta.protocols.dna.DesignProteinBackboneAroundDNA, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse XML (specifically in the context of the parser/scripting scheme)

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

parse_score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse “scorefxn” XML option (can be employed virtually by derived Packing movers)

C++: protocols::minimization_packing::PackRotamersMover::parse_score_function(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> void

parse_task_operations(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse “task_operations” XML option (can be employed virtually by derived Packing movers)

C++: protocols::minimization_packing::PackRotamersMover::parse_task_operations(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> void

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

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::dna::DesignProteinBackboneAroundDNA::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

rotamer_sets(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) → pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets¶

Returns the RotamerSets object being used for packing

This is only valid after a call to setup or apply.

C++: protocols::minimization_packing::PackRotamersMover::rotamer_sets() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerSets>

score_function(*args, **kwargs)¶

Overloaded function.

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Sets the ScoreFunction to <sf>

example(s):
packmover.score_function(scorefxn)

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::score_function(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns the ScoreFunction

example(s):
packmover.score_function()

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::score_function() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_annealer_observer(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, observer: pyrosetta.rosetta.core.pack.annealer.AnnealerObserver) → None¶: C++: protocols::minimization_packing::PackRotamersMover::set_annealer_observer(class std::shared_ptr<class core::pack::annealer::AnnealerObserver>) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

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

setter for poses contained for rms

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

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

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

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

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::minimization_packing::PackRotamersMover::show(std::ostream &) const –> void

targeted_dna(*args, **kwargs)¶

Overloaded function.

targeted_dna(self: pyrosetta.rosetta.protocols.dna.DesignProteinBackboneAroundDNA, : pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t) -> None

C++: protocols::dna::DesignProteinBackboneAroundDNA::targeted_dna(const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &) –> void

targeted_dna(self: pyrosetta.rosetta.protocols.dna.DesignProteinBackboneAroundDNA) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t

C++: protocols::dna::DesignProteinBackboneAroundDNA::targeted_dna() const –> const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &

task(*args, **kwargs)¶

Overloaded function.

task(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, t: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

Sets the PackerTask to <t>

example(s):
packmover.task(task_pack)

See Also:
PackRotamersMover PackRotamersMover.task_factory

C++: protocols::minimization_packing::PackRotamersMover::task(class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

task(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.pack.task.PackerTask

Returns the PackerTask

example(s):
packmover.task()

See Also:
PackRotamersMover PackRotamersMover.task_factory

C++: protocols::minimization_packing::PackRotamersMover::task() const –> class std::shared_ptr<const class core::pack::task::PackerTask>

task_factory(*args, **kwargs)¶

Overloaded function.

task_factory(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None

Sets the TaskFactory to <tf>

example(s):
packmover.task_factory(task_design)

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

task_factory(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Returns the TaskFactory

example(s):
packmover.task_factory()

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::task_factory() const –> class std::shared_ptr<const class core::pack::task::TaskFactory>

task_is_valid(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::minimization_packing::PackRotamersMover::task_is_valid(const class core::pose::Pose &) const –> bool

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

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.dna.DesignProteinBackboneAroundDNACreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.dna.DnaChains¶

Bases: pybind11_object

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

clear(self: pyrosetta.rosetta.protocols.dna.DnaChains) → None¶: C++: protocols::dna::DnaChains::clear() –> void

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

contains(self: pyrosetta.rosetta.protocols.dna.DnaChains, index: int) → bool¶: C++: protocols::dna::DnaChains::contains(unsigned long) const –> bool

empty(self: pyrosetta.rosetta.protocols.dna.DnaChains) → bool¶: C++: protocols::dna::DnaChains::empty() const –> bool

is_top(self: pyrosetta.rosetta.protocols.dna.DnaChains, index: int) → bool¶: C++: protocols::dna::DnaChains::is_top(unsigned long) const –> bool

positions(self: pyrosetta.rosetta.protocols.dna.DnaChains) → pyrosetta.rosetta.std.map_unsigned_long_protocols_dna_DnaPosition¶: C++: protocols::dna::DnaChains::positions() –> class std::map<unsigned long, class protocols::dna::DnaPosition, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class protocols::dna::DnaPosition> > > &

print(self: pyrosetta.rosetta.protocols.dna.DnaChains, pose: pyrosetta.rosetta.core.pose.Pose, os: pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::dna::DnaChains::print(const class core::pose::Pose &, std::ostream &) const –> void

size(self: pyrosetta.rosetta.protocols.dna.DnaChains) → int¶: C++: protocols::dna::DnaChains::size() const –> unsigned long

class pyrosetta.rosetta.protocols.dna.DnaDesignDef¶

Bases: pybind11_object

command-line dna_defs are of the format “C.501.ADE” they are parsed here into this little class for convenience

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

property chain¶

property name3¶

property pdbpos¶

class pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder¶

Bases: pybind11_object

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

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

determine_dna_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder, pose: pyrosetta.rosetta.core.pose.Pose, protein_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, dna_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: protocols::dna::DnaInterfaceFinder::determine_dna_interface(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

determine_interface(*args, **kwargs)¶

Overloaded function.

determine_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder, pose: pyrosetta.rosetta.core.pose.Pose, protein_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, dna_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::dna::DnaInterfaceFinder::determine_interface(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

determine_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::dna::DnaInterfaceFinder::determine_interface(const class core::pose::Pose &) –> void

determine_protein_interface(*args, **kwargs)¶

Overloaded function.

determine_protein_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder, pose: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::dna::DnaInterfaceFinder::determine_protein_interface(const class core::pose::Pose &) –> void

determine_protein_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder, pose: pyrosetta.rosetta.core.pose.Pose, protein_positions: pyrosetta.rosetta.utility.vector1_unsigned_long, dna_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: protocols::dna::DnaInterfaceFinder::determine_protein_interface(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

dna_neighbors(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder) → pyrosetta.rosetta.std.map_unsigned_long_protocols_dna_DnaNeighbor¶: C++: protocols::dna::DnaInterfaceFinder::dna_neighbors() const –> const class std::map<unsigned long, class protocols::dna::DnaNeighbor, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class protocols::dna::DnaNeighbor> > > &

initialized(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder) → bool¶: C++: protocols::dna::DnaInterfaceFinder::initialized() const –> bool

protein_neighbors(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder) → pyrosetta.rosetta.std.map_unsigned_long_protocols_dna_DnaNeighbor¶: C++: protocols::dna::DnaInterfaceFinder::protein_neighbors() const –> const class std::map<unsigned long, class protocols::dna::DnaNeighbor, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class protocols::dna::DnaNeighbor> > > &

class pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover¶

Bases: MinMover

abs_score_convergence_threshold(*args, **kwargs)¶

Overloaded function.

abs_score_convergence_threshold(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, newval: float) -> None

C++: protocols::minimization_packing::MinMover::abs_score_convergence_threshold(double) –> void

abs_score_convergence_threshold(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> float

C++: protocols::minimization_packing::MinMover::abs_score_convergence_threshold() const –> double

abs_score_diff_after_minimization(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) → float¶: C++: protocols::minimization_packing::MinMover::abs_score_diff_after_minimization() const –> double

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

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

bb(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover, value: bool) → None¶: C++: protocols::dna::DnaInterfaceMinMover::bb(bool) –> void

cartesian(*args, **kwargs)¶

Overloaded function.

cartesian(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, newval: bool) -> None

C++: protocols::minimization_packing::MinMover::cartesian(bool) –> void

cartesian(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> bool

C++: protocols::minimization_packing::MinMover::cartesian() const –> bool

chi(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover, value: bool) → None¶: C++: protocols::dna::DnaInterfaceMinMover::chi(bool) –> void

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

required in the context of the parser/scripting scheme

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

static complex_type_generator_for_min_mover(xsd: utility::tag::XMLSchemaDefinition) → utility::tag::XMLSchemaComplexTypeGenerator¶: C++: protocols::minimization_packing::MinMover::complex_type_generator_for_min_mover(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

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>

deriv_check(*args, **kwargs)¶

Overloaded function.

deriv_check(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, deriv_check_in: bool) -> None

C++: protocols::minimization_packing::MinMover::deriv_check(bool) –> void

deriv_check(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> bool

C++: protocols::minimization_packing::MinMover::deriv_check() const –> bool

explicitly_set_movemap(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) → pyrosetta.rosetta.core.kinematics.MoveMap¶

Get the explicitly set movemap object, if present, nullptr if not: Will not create a default or look at the MoveMapFactory

C++: protocols::minimization_packing::MinMover::explicitly_set_movemap() const –> class std::shared_ptr<const class core::kinematics::MoveMap>

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

required in the context of the parser/scripting scheme

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

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

fpd

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

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

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

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

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

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

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

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

get_name(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover) → str¶: C++: protocols::dna::DnaInterfaceMinMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

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

non-const accessor

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

initialize(self: pyrosetta.rosetta.protocols.moves.MoveMapMover, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::moves::MoveMapMover::initialize(class core::pose::Pose &) –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

max_iter(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, max_iter_in: int) → None¶: C++: protocols::minimization_packing::MinMover::max_iter(unsigned long) –> void

min_options(*args, **kwargs)¶

Overloaded function.

min_options(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> pyrosetta.rosetta.core.optimization.MinimizerOptions

allow non-const access to the internal minimizer options object

C++: protocols::minimization_packing::MinMover::min_options() –> class std::shared_ptr<class core::optimization::MinimizerOptions>

min_options(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, min_options: pyrosetta.rosetta.core.optimization.MinimizerOptions) -> None

directly set the internal minimizer options object

C++: protocols::minimization_packing::MinMover::min_options(class std::shared_ptr<class core::optimization::MinimizerOptions>) –> void

min_type(*args, **kwargs)¶

Overloaded function.

min_type(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, min_type_in: str) -> None

C++: protocols::minimization_packing::MinMover::min_type(std::string) –> void

min_type(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> str

C++: protocols::minimization_packing::MinMover::min_type() const –> std::string

movemap(*args, **kwargs)¶

Overloaded function.

movemap(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, movemap_in: pyrosetta.rosetta.core.kinematics.MoveMap) -> None

Sets the MoveMap to <movemap_in>

determines which DOF to minimize

example(s):: minmover.movemap(movemap1)
See also:: MinMover MinMover.apply MinMover.score_function MoveMap

C++: protocols::minimization_packing::MinMover::movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

movemap(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.kinematics.MoveMap

Get the movemap for the pose

This is the preferred version to call.

C++: protocols::minimization_packing::MinMover::movemap(const class core::pose::Pose &) const –> class std::shared_ptr<const class core::kinematics::MoveMap>

movemap_factory(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, mmf: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) → None¶

Sets the MoveMapFactory: The MoveMapFactory will be used to construct a MoveMap if an explicit one isn’t set

C++: protocols::minimization_packing::MinMover::movemap_factory(class std::shared_ptr<const class core::select::movemap::MoveMapFactory>) –> void

static mover_name() → str¶: C++: protocols::dna::DnaInterfaceMinMover::mover_name() –> std::string

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

nb_list(*args, **kwargs)¶

Overloaded function.

nb_list(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, nb_list_in: bool) -> None

core::optimization::MinimizerOptions::use_nblist(bool)

C++: protocols::minimization_packing::MinMover::nb_list(bool) –> void

nb_list(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> bool

core::optimization::MinimizerOptions::use_nblist()

C++: protocols::minimization_packing::MinMover::nb_list() const –> bool

omega(*args, **kwargs)¶

Overloaded function.

omega(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> bool

C++: protocols::minimization_packing::MinMover::omega() const –> bool

omega(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, b: bool) -> None

C++: protocols::minimization_packing::MinMover::omega(const bool) –> void

parse_dof_task_type(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, tag_name: str, dof_type: pyrosetta.rosetta.core.id.DOF_Type, torsion_type: pyrosetta.rosetta.core.id.TorsionType, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::minimization_packing::MinMover::parse_dof_task_type(const std::string &, enum core::id::DOF_Type, enum core::id::TorsionType, class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

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

parse_my_tag(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse XML (specifically in the context of the parser/scripting scheme)

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

parse_opts(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, : pyrosetta.rosetta.utility.tag.Tag, data_map: pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::minimization_packing::MinMover::parse_opts(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

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

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::dna::DnaInterfaceMinMover::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_from_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover) → None¶: C++: protocols::dna::DnaInterfaceMinMover::reset_from_interface() –> void

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

score_diff_after_minimization(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) → float¶: C++: protocols::minimization_packing::MinMover::score_diff_after_minimization() const –> double

score_function(*args, **kwargs)¶

Overloaded function.

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, scorefxn_in: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Sets the ScoreFunction to <scorefxn_in>

determines which function to minimize

example(s):: minmover.score_function(scorefxn)
See also:: MinMover MinMover.apply MinMover.movemap ScoreFunction

C++: protocols::minimization_packing::MinMover::score_function(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::minimization_packing::MinMover::score_function() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

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

setter for poses contained for rms

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

set_movemap(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, movemap_in: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶: C++: protocols::minimization_packing::MinMover::set_movemap(class std::shared_ptr<const class core::kinematics::MoveMap>) –> void

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

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

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

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::minimization_packing::MinMover::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

tolerance(*args, **kwargs)¶

Overloaded function.

tolerance(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover, tolerance_in: float) -> None

C++: protocols::minimization_packing::MinMover::tolerance(double) –> void

tolerance(self: pyrosetta.rosetta.protocols.minimization_packing.MinMover) -> float

C++: protocols::minimization_packing::MinMover::tolerance() const –> double

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

use_interface(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMover, : pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder) → None¶: C++: protocols::dna::DnaInterfaceMinMover::use_interface(class std::shared_ptr<class protocols::dna::DnaInterfaceFinder>) –> void

class pyrosetta.rosetta.protocols.dna.DnaInterfaceMinMoverCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesign¶

Bases: PackRotamersMover

wraps DNA-interface specific considerations around the general multistate design / genetic algorithm framework

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

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

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

required in the context of the parser/scripting scheme

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

static complex_type_generator_for_pack_rotamers_mover(xsd: utility::tag::XMLSchemaDefinition) → utility::tag::XMLSchemaComplexTypeGenerator¶: C++: protocols::minimization_packing::PackRotamersMover::complex_type_generator_for_pack_rotamers_mover(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

copy_dna_chains(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesign, : pyrosetta.rosetta.protocols.dna.DnaChains) → None¶: C++: protocols::dna::DnaInterfaceMultiStateDesign::copy_dna_chains(class std::shared_ptr<class protocols::dna::DnaChains>) –> void

copy_targeted_dna(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesign, : pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t) → None¶: C++: protocols::dna::DnaInterfaceMultiStateDesign::copy_targeted_dna(const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &) –> void

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

required in the context of the parser/scripting scheme

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

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

fpd

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

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

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

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

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

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

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

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

get_name(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesign) → str¶: C++: protocols::dna::DnaInterfaceMultiStateDesign::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

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

non-const accessor

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

initialize_task_factory_with_operations(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.std.list_std_shared_ptr_core_pack_task_operation_TaskOperation_t) → None¶: C++: protocols::minimization_packing::PackRotamersMover::initialize_task_factory_with_operations(const class std::list<class std::shared_ptr<class core::pack::task::operation::TaskOperation>, class std::allocator<class std::shared_ptr<class core::pack::task::operation::TaskOperation> > > &) –> void

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static list_options_read(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None¶: C++: protocols::minimization_packing::PackRotamersMover::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

static mover_name() → str¶: C++: protocols::dna::DnaInterfaceMultiStateDesign::mover_name() –> std::string

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

nloop(*args, **kwargs)¶

Overloaded function.

nloop(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, nloop_in: int) -> None

C++: protocols::minimization_packing::PackRotamersMover::nloop(unsigned long) –> void

nloop(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> int

C++: protocols::minimization_packing::PackRotamersMover::nloop() const –> unsigned long

output_results(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesign, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::dna::DnaInterfaceMultiStateDesign::output_results(class core::pose::Pose &) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesign, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse XML (specifically in the context of the parser/scripting scheme)

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

parse_score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse “scorefxn” XML option (can be employed virtually by derived Packing movers)

C++: protocols::minimization_packing::PackRotamersMover::parse_score_function(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> void

parse_task_operations(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse “task_operations” XML option (can be employed virtually by derived Packing movers)

C++: protocols::minimization_packing::PackRotamersMover::parse_task_operations(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> void

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

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::dna::DnaInterfaceMultiStateDesign::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

rotamer_sets(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) → pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets¶

Returns the RotamerSets object being used for packing

This is only valid after a call to setup or apply.

C++: protocols::minimization_packing::PackRotamersMover::rotamer_sets() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerSets>

score_function(*args, **kwargs)¶

Overloaded function.

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Sets the ScoreFunction to <sf>

example(s):
packmover.score_function(scorefxn)

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::score_function(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns the ScoreFunction

example(s):
packmover.score_function()

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::score_function() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_annealer_observer(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, observer: pyrosetta.rosetta.core.pack.annealer.AnnealerObserver) → None¶: C++: protocols::minimization_packing::PackRotamersMover::set_annealer_observer(class std::shared_ptr<class core::pack::annealer::AnnealerObserver>) –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

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

setter for poses contained for rms

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

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

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

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

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::minimization_packing::PackRotamersMover::show(std::ostream &) const –> void

task(*args, **kwargs)¶

Overloaded function.

task(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, t: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

Sets the PackerTask to <t>

example(s):
packmover.task(task_pack)

See Also:
PackRotamersMover PackRotamersMover.task_factory

C++: protocols::minimization_packing::PackRotamersMover::task(class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

task(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.pack.task.PackerTask

Returns the PackerTask

example(s):
packmover.task()

See Also:
PackRotamersMover PackRotamersMover.task_factory

C++: protocols::minimization_packing::PackRotamersMover::task() const –> class std::shared_ptr<const class core::pack::task::PackerTask>

task_factory(*args, **kwargs)¶

Overloaded function.

task_factory(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None

Sets the TaskFactory to <tf>

example(s):
packmover.task_factory(task_design)

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

task_factory(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Returns the TaskFactory

example(s):
packmover.task_factory()

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::task_factory() const –> class std::shared_ptr<const class core::pack::task::TaskFactory>

task_is_valid(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::minimization_packing::PackRotamersMover::task_is_valid(const class core::pose::Pose &) const –> bool

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

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.dna.DnaInterfaceMultiStateDesignCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.dna.DnaInterfacePacker¶

Bases: PackRotamersMover

allowed_types(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → str¶: C++: protocols::dna::DnaInterfacePacker::allowed_types() const –> std::string

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

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

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

clear_initialization(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → None¶: C++: protocols::dna::DnaInterfacePacker::clear_initialization() –> void

clone(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::dna::DnaInterfacePacker::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

static complex_type_generator_for_pack_rotamers_mover(xsd: utility::tag::XMLSchemaDefinition) → utility::tag::XMLSchemaComplexTypeGenerator¶: C++: protocols::minimization_packing::PackRotamersMover::complex_type_generator_for_pack_rotamers_mover(class utility::tag::XMLSchemaDefinition &) –> class std::shared_ptr<class utility::tag::XMLSchemaComplexTypeGenerator>

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>

current_dna_design_string(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) → str¶: C++: protocols::dna::DnaInterfacePacker::current_dna_design_string(const class core::pose::Pose &) const –> std::string

current_working_sequence(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t¶: C++: protocols::dna::DnaInterfacePacker::current_working_sequence(const class core::pose::Pose &) const –> class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >

dna_seq_tag(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t) → str¶: C++: protocols::dna::DnaInterfacePacker::dna_seq_tag(const class core::pose::Pose &, const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > &) const –> std::string

fresh_instance(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → pyrosetta.rosetta.protocols.moves.Mover¶: C++: protocols::dna::DnaInterfacePacker::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

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

fpd

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

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

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

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

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

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

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

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

get_name(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → str¶: C++: protocols::dna::DnaInterfacePacker::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_targeted_sequence(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t¶: C++: protocols::dna::DnaInterfacePacker::get_targeted_sequence(const class core::pose::Pose &) const –> class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >

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

initialize_task_factory_with_operations(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.std.list_std_shared_ptr_core_pack_task_operation_TaskOperation_t) → None¶: C++: protocols::minimization_packing::PackRotamersMover::initialize_task_factory_with_operations(const class std::list<class std::shared_ptr<class core::pack::task::operation::TaskOperation>, class std::allocator<class std::shared_ptr<class core::pack::task::operation::TaskOperation> > > &) –> void

initialized(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → bool¶: C++: protocols::dna::DnaInterfacePacker::initialized() const –> bool

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static list_options_read(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None¶: C++: protocols::minimization_packing::PackRotamersMover::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

measure_bp_specificities(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) → Tuple[std::map<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > >, double, protocols::dna::ResTypeSequence_lt, std::allocator<std::pair<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > > const, double> > >, std::map<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > >, double, protocols::dna::ResTypeSequence_lt, std::allocator<std::pair<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > > const, double> > >]¶: C++: protocols::dna::DnaInterfacePacker::measure_bp_specificities(class core::pose::Pose &) –> struct std::pair<class std::map<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double, class protocols::dna::ResTypeSequence_lt, class std::allocator<struct std::pair<const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double> > >, class std::map<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double, class protocols::dna::ResTypeSequence_lt, class std::allocator<struct std::pair<const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double> > > >

measure_specificities(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.utility.vector1_std_map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_std_less_unsigned_long_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t) → Tuple[std::map<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > >, double, protocols::dna::ResTypeSequence_lt, std::allocator<std::pair<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > > const, double> > >, std::map<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > >, double, protocols::dna::ResTypeSequence_lt, std::allocator<std::pair<std::map<unsigned long, std::shared_ptr<core::chemical::ResidueType const>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::shared_ptr<core::chemical::ResidueType const> > > > const, double> > >]¶: C++: protocols::dna::DnaInterfacePacker::measure_specificities(class core::pose::Pose &, const class utility::vector1<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, class std::allocator<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > > > &) –> struct std::pair<class std::map<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double, class protocols::dna::ResTypeSequence_lt, class std::allocator<struct std::pair<const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double> > >, class std::map<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double, class protocols::dna::ResTypeSequence_lt, class std::allocator<struct std::pair<const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, double> > > >

measure_specificity(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) → Tuple[float, float]¶: C++: protocols::dna::DnaInterfacePacker::measure_specificity(class core::pose::Pose &) –> struct std::pair<double, double>

static mover_name() → str¶: C++: protocols::dna::DnaInterfacePacker::mover_name() –> std::string

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

nloop(*args, **kwargs)¶

Overloaded function.

nloop(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, nloop_in: int) -> None

C++: protocols::minimization_packing::PackRotamersMover::nloop(unsigned long) –> void

nloop(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> int

C++: protocols::minimization_packing::PackRotamersMover::nloop() const –> unsigned long

parse_my_tag(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse XML (specifically in the context of the parser/scripting scheme)

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

parse_score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse “scorefxn” XML option (can be employed virtually by derived Packing movers)

C++: protocols::minimization_packing::PackRotamersMover::parse_score_function(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> void

parse_task_operations(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse “task_operations” XML option (can be employed virtually by derived Packing movers)

C++: protocols::minimization_packing::PackRotamersMover::parse_task_operations(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> void

pdbname(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) → str¶: C++: protocols::dna::DnaInterfacePacker::pdbname() –> std::string

pdboutput(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : protocols::dna::PDBOutput) → None¶: C++: protocols::dna::DnaInterfacePacker::pdboutput(class std::shared_ptr<class protocols::dna::PDBOutput>) –> void

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

Provide citations to the passed CitationCollectionList

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

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

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

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

reference_pose(*args, **kwargs)¶

Overloaded function.

reference_pose(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::dna::DnaInterfacePacker::reference_pose(const class core::pose::Pose &) –> void

reference_pose(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) -> pyrosetta.rosetta.core.pose.Pose

C++: protocols::dna::DnaInterfacePacker::reference_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

reversion_scan(*args, **kwargs)¶

Overloaded function.

reversion_scan(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) -> None
reversion_scan(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, bound_score: float) -> None
reversion_scan(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, bound_score: float, binding_score: float) -> None
reversion_scan(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, bound_score: float, binding_score: float, specificities: Tuple[float, float]) -> None

C++: protocols::dna::DnaInterfacePacker::reversion_scan(class core::pose::Pose &, double, double, struct std::pair<double, double>) –> void

rotamer_sets(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) → pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets¶

Returns the RotamerSets object being used for packing

This is only valid after a call to setup or apply.

C++: protocols::minimization_packing::PackRotamersMover::rotamer_sets() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerSets>

score_function(*args, **kwargs)¶

Overloaded function.

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Sets the ScoreFunction to <sf>

example(s):
packmover.score_function(scorefxn)

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::score_function(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

score_function(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns the ScoreFunction

example(s):
packmover.score_function()

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::score_function() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

set_annealer_observer(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, observer: pyrosetta.rosetta.core.pack.annealer.AnnealerObserver) → None¶: C++: protocols::minimization_packing::PackRotamersMover::set_annealer_observer(class std::shared_ptr<class core::pack::annealer::AnnealerObserver>) –> 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_filename_root(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, name: str) → None¶: C++: protocols::dna::DnaInterfacePacker::set_filename_root(const std::string &) –> void

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

setter for poses contained for rms

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

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

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

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

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::minimization_packing::PackRotamersMover::show(std::ostream &) const –> void

targeted_dna(*args, **kwargs)¶

Overloaded function.

targeted_dna(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t) -> None

C++: protocols::dna::DnaInterfacePacker::targeted_dna(const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &) –> void

targeted_dna(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker) -> pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t

C++: protocols::dna::DnaInterfacePacker::targeted_dna() const –> const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &

task(*args, **kwargs)¶

Overloaded function.

task(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, t: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

Sets the PackerTask to <t>

example(s):
packmover.task(task_pack)

See Also:
PackRotamersMover PackRotamersMover.task_factory

C++: protocols::minimization_packing::PackRotamersMover::task(class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

task(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.pack.task.PackerTask

Returns the PackerTask

example(s):
packmover.task()

See Also:
PackRotamersMover PackRotamersMover.task_factory

C++: protocols::minimization_packing::PackRotamersMover::task() const –> class std::shared_ptr<const class core::pack::task::PackerTask>

task_factory(*args, **kwargs)¶

Overloaded function.

task_factory(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None

Sets the TaskFactory to <tf>

example(s):
packmover.task_factory(task_design)

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::task_factory(class std::shared_ptr<const class core::pack::task::TaskFactory>) –> void

task_factory(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Returns the TaskFactory

example(s):
packmover.task_factory()

See Also:
PackRotamersMover PackRotamersMover.task

C++: protocols::minimization_packing::PackRotamersMover::task_factory() const –> class std::shared_ptr<const class core::pack::task::TaskFactory>

task_is_valid(self: pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::minimization_packing::PackRotamersMover::task_is_valid(const class core::pose::Pose &) const –> bool

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

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

unbound_score(*args, **kwargs)¶

Overloaded function.

unbound_score(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose) -> float
unbound_score(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, output_pdb: bool) -> float
unbound_score(self: pyrosetta.rosetta.protocols.dna.DnaInterfacePacker, : pyrosetta.rosetta.core.pose.Pose, output_pdb: bool, pdbname: str) -> float

C++: protocols::dna::DnaInterfacePacker::unbound_score(const class core::pose::Pose &, bool, std::string) –> double

class pyrosetta.rosetta.protocols.dna.DnaInterfacePackerCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.dna.DnaNeighbor¶

Bases: pybind11_object

close(*args, **kwargs)¶

Overloaded function.

close(self: pyrosetta.rosetta.protocols.dna.DnaNeighbor, val: bool) -> None

C++: protocols::dna::DnaNeighbor::close(bool) –> void

close(self: pyrosetta.rosetta.protocols.dna.DnaNeighbor) -> bool

C++: protocols::dna::DnaNeighbor::close() const –> bool

contact(*args, **kwargs)¶

Overloaded function.

contact(self: pyrosetta.rosetta.protocols.dna.DnaNeighbor, val: bool) -> None

C++: protocols::dna::DnaNeighbor::contact(bool) –> void

contact(self: pyrosetta.rosetta.protocols.dna.DnaNeighbor) -> bool

C++: protocols::dna::DnaNeighbor::contact() const –> bool

class pyrosetta.rosetta.protocols.dna.DnaPosition¶

Bases: pybind11_object

bottom(self: pyrosetta.rosetta.protocols.dna.DnaPosition) → int¶: C++: protocols::dna::DnaPosition::bottom() const –> unsigned long

paired(self: pyrosetta.rosetta.protocols.dna.DnaPosition) → bool¶: C++: protocols::dna::DnaPosition::paired() const –> bool

top(self: pyrosetta.rosetta.protocols.dna.DnaPosition) → int¶: C++: protocols::dna::DnaPosition::top() const –> unsigned long

class pyrosetta.rosetta.protocols.dna.PDBOutput¶

Bases: PDBJobOutputter

add_evaluation(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.PoseEvaluator) → None¶

////////////////////////////// evaluator interface ////////////////////////////////////////////

C++: protocols::jd2::JobOutputter::add_evaluation(class std::shared_ptr<class protocols::evaluation::PoseEvaluator>) –> void

add_info(*args, **kwargs)¶

Overloaded function.

add_info(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : str, : pyrosetta.rosetta.std.list_std_string_t) -> None
add_info(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : str, : pyrosetta.rosetta.std.list_std_string_t, append: bool) -> None

C++: protocols::dna::PDBOutput::add_info(const std::string &, const class std::list<std::string, class std::allocator<std::string > > &, bool) –> void

call_output_observers(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, job: protocols::jd2::Job) → None¶

call all output_observers

C++: protocols::jd2::JobOutputter::call_output_observers(const class core::pose::Pose &, class std::shared_ptr<class protocols::jd2::Job>) const –> void

clear_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None¶: C++: protocols::jd2::JobOutputter::clear_evaluators() –> void

designed_residue(*args, **kwargs)¶

Overloaded function.

designed_residue(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : int) -> None
designed_residue(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : int, value: bool) -> None

C++: protocols::dna::PDBOutput::designed_residue(unsigned long, bool) –> void

enabled(*args, **kwargs)¶

Overloaded function.

enabled(self: pyrosetta.rosetta.protocols.dna.PDBOutput, value: bool) -> None

C++: protocols::dna::PDBOutput::enabled(bool) const –> void

enabled(self: pyrosetta.rosetta.protocols.dna.PDBOutput) -> bool

C++: protocols::dna::PDBOutput::enabled() const –> bool

evaluate(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, pss: pyrosetta.rosetta.core.io.silent.SilentStruct) → None¶: C++: protocols::jd2::JobOutputter::evaluate(class core::pose::Pose &, std::string, class core::io::silent::SilentStruct &) const –> void

evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator¶: C++: protocols::jd2::JobOutputter::evaluators() const –> class std::shared_ptr<const class protocols::evaluation::MetaPoseEvaluator>

file(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter, job: protocols::jd2::Job, data: str) → None¶

this function takes a string and writes it to disk (separately from Tracer output).

C++: protocols::jd2::FileJobOutputter::file(class std::shared_ptr<const class protocols::jd2::Job>, const std::string &) –> void

filename(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : protocols::jd2::Job) → str¶: C++: protocols::jd2::JobOutputter::filename(class std::shared_ptr<const class protocols::jd2::Job>) const –> std::string

final_pose(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : protocols::jd2::Job, : pyrosetta.rosetta.core.pose.Pose, : str) → None¶

JobDistributor calls this method

C++: protocols::dna::PDBOutput::final_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const std::string &) –> void

flush(self: pyrosetta.rosetta.protocols.jd2.JobOutputter) → None¶

this function is meant to be redefined in child classes to allow for flushing of memory buffers.

Here’s the long version: The SilentFileJobOutputter wanted to buffer output, but needed to guaruntee that the output would be flushed at end of runtime. The original implementation was to A) bend over backward to ensure that the destructor was run (JobOutputter lives inside static JobDistributor, which was previously not destructed because it’s static) and B) flush the buffers in the destructor. This caused a problem because the buffer-flushing tried to use the Tracers, which had already been destructed…boom crash.

New solution: re-forbid use of destructors within the static JobDistributor system, and create a flush function to force this stuff out. So here it is:

C++: protocols::jd2::JobOutputter::flush() –> void

job_has_completed(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → bool¶

this function is not used for output, but it belongs here since it needs to check the same output locations as the class normally writes to. This class checks wherever output goes to see if the job’s expected output already exists (on disk or whatever). This is the most basic form of checkpointing. The base implementation looks for a pdb/cif with the job’s name already in existence.

C++: protocols::jd2::wwPDBJobOutputter::job_has_completed(class std::shared_ptr<const class protocols::jd2::Job>) –> bool

note_designed_residues(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::dna::PDBOutput::note_designed_residues(class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

other_pose(*args, **kwargs)¶

Overloaded function.

other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str) -> None
other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int) -> None
other_pose(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job, pose: pyrosetta.rosetta.core.pose.Pose, tag: str, copy_count: int, score_only: bool) -> None

this function is intended for saving mid-protocol poses; for example the final centroid structure in a combined centroid/fullatom protocol. This implementation will write a wwPDB-format file (plus scores). It calls a pure virtual so that child classes can write PDB or mmCIF format.

C++: protocols::jd2::wwPDBJobOutputter::other_pose(class std::shared_ptr<class protocols::jd2::Job>, const class core::pose::Pose &, const std::string &, int, bool) –> void

output_name(self: pyrosetta.rosetta.protocols.jd2.wwPDBJobOutputter, job: protocols::jd2::Job) → str¶

this is the master function for determining the unique output identifier for a job

C++: protocols::jd2::wwPDBJobOutputter::output_name(class std::shared_ptr<const class protocols::jd2::Job>) –> std::string

reference_pose(*args, **kwargs)¶

Overloaded function.

reference_pose(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::dna::PDBOutput::reference_pose(const class core::pose::Pose &) –> void

reference_pose(self: pyrosetta.rosetta.protocols.dna.PDBOutput) -> pyrosetta.rosetta.core.pose.Pose

C++: protocols::dna::PDBOutput::reference_pose() const –> class std::shared_ptr<const class core::pose::Pose>

remove_info(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : str) → bool¶: C++: protocols::dna::PDBOutput::remove_info(const std::string &) –> bool

residues_are_different(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.conformation.Residue) → bool¶: C++: protocols::dna::PDBOutput::residues_are_different(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> bool

score_function(*args, **kwargs)¶

Overloaded function.

score_function(self: pyrosetta.rosetta.protocols.dna.PDBOutput, sf: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

C++: protocols::dna::PDBOutput::score_function(const class core::scoring::ScoreFunction &) –> void

score_function(self: pyrosetta.rosetta.protocols.dna.PDBOutput) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::dna::PDBOutput::score_function() const –> class std::shared_ptr<const class core::scoring::ScoreFunction>

scorefile_name(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → pyrosetta.rosetta.utility.file.FileName¶: C++: protocols::jd2::FileJobOutputter::scorefile_name() –> const class utility::file::FileName &

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

set_evaluators(self: pyrosetta.rosetta.protocols.jd2.JobOutputter, : pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None¶: C++: protocols::jd2::JobOutputter::set_evaluators(const class protocols::evaluation::MetaPoseEvaluator &) –> void

starting_pose(self: pyrosetta.rosetta.protocols.dna.PDBOutput, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::dna::PDBOutput::starting_pose(const class core::pose::Pose &) –> void

write_scorefile(self: pyrosetta.rosetta.protocols.jd2.FileJobOutputter) → bool¶: C++: protocols::jd2::FileJobOutputter::write_scorefile() const –> bool

class pyrosetta.rosetta.protocols.dna.PositionType¶

Bases: pybind11_object

basic struct for remembering position/type information before/during/after design

property designable¶

property position¶

property type¶

class pyrosetta.rosetta.protocols.dna.ResTypeSequence_lt¶: Bases: pybind11_object

class pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface¶

Bases: TaskOperation

apply(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, pose: pyrosetta.rosetta.core.pose.Pose, ptask: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

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

base_only(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → bool¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::base_only() const –> bool

clone(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

copy_dna_chains(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, chains: pyrosetta.rosetta.protocols.dna.DnaChains) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::copy_dna_chains(class std::shared_ptr<const class protocols::dna::DnaChains>) –> void

copy_interface(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, interface: pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::copy_interface(class std::shared_ptr<const class protocols::dna::DnaInterfaceFinder>) –> void

copy_targeted_dna(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, targeted_dna: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::copy_targeted_dna(const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &) –> void

dna_chains(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → pyrosetta.rosetta.protocols.dna.DnaChains¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::dna_chains() const –> class std::shared_ptr<const class protocols::dna::DnaChains>

forget_chains_and_interface(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → bool¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::forget_chains_and_interface() const –> bool

interface(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → pyrosetta.rosetta.protocols.dna.DnaInterfaceFinder¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::interface() const –> class std::shared_ptr<const class protocols::dna::DnaInterfaceFinder>

static keyname() → str¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::keyname() –> std::string

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

provide_citation_info(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : 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 task operations wishing to provide citation information.

C++: core::pack::task::operation::TaskOperation::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

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

reference_pose(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::reference_pose() const –> class std::shared_ptr<const class core::pose::Pose>

set_base_only(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, value: bool) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::set_base_only(bool) –> void

set_forget_chains_and_interface(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, value: bool) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::set_forget_chains_and_interface(bool) –> void

set_reference_pose(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::set_reference_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

targeted_dna(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterface) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t¶: C++: protocols::dna::RestrictDesignToProteinDNAInterface::targeted_dna() const –> const class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &

class pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterfaceCreator¶

Bases: TaskOperationCreator

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

create_task_operation(self: pyrosetta.rosetta.protocols.dna.RestrictDesignToProteinDNAInterfaceCreator) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::dna::RestrictDesignToProteinDNAInterfaceCreator::create_task_operation() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

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

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

skip_citation_info_in_schema(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperationCreator) → bool¶

Indicate whether we skip adding citation information to the XML schema.

False for any real task operation. True only for dummy task operations created for unit tests.

C++: core::pack::task::operation::TaskOperationCreator::skip_citation_info_in_schema() const –> bool

class pyrosetta.rosetta.protocols.dna.RotamerDNAHBondFilter¶

Bases: RotamerOperation

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

report(self: pyrosetta.rosetta.protocols.dna.RotamerDNAHBondFilter) → None¶: C++: protocols::dna::RotamerDNAHBondFilter::report() const –> void

class pyrosetta.rosetta.protocols.dna.SeparateDnaFromNonDna¶

Bases: Mover

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

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

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

required in the context of the parser/scripting scheme

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

required in the context of the parser/scripting scheme

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

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

fpd

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

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

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

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob¶: C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

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

A tag is a unique identifier used to identify structures produced: by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

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

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

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

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

get_name(self: pyrosetta.rosetta.protocols.dna.SeparateDnaFromNonDna) → str¶: C++: protocols::dna::SeparateDnaFromNonDna::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

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

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t¶: C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str¶: C++: protocols::moves::Mover::get_type() const –> std::string

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

non-const accessor

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

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float¶: C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static mover_name() → str¶: C++: protocols::dna::SeparateDnaFromNonDna::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.dna.SeparateDnaFromNonDna, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶

parse XML (specifically in the context of the parser/scripting scheme)

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

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

Provide citations to the passed CitationCollectionList

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

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

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

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

static register_options() → None¶

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

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

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

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

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

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

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

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input: pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

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

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

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

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

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None¶: C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None¶: C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

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

setter for poses contained for rms

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

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

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

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

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

Set the ‘type’ string

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

show(*args, **kwargs)¶

Overloaded function.

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

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(std::ostream &) const –> void

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

: Unit test support function. Apply one move to a given pose.: Allows extra test specific functions to be called before applying

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

translation(self: pyrosetta.rosetta.protocols.dna.SeparateDnaFromNonDna) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: protocols::dna::SeparateDnaFromNonDna::translation() const –> class numeric::xyzVector<double>

type(*args, **kwargs)¶

Overloaded function.

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

Set the ‘type’ string

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

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

Get the set ‘type’ string

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

class pyrosetta.rosetta.protocols.dna.SeparateDnaFromNonDnaCreator¶

Bases: MoverCreator

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

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

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

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

class pyrosetta.rosetta.protocols.dna.WatsonCrickRotamerCouplings¶

Bases: TaskOperation

apply(self: pyrosetta.rosetta.protocols.dna.WatsonCrickRotamerCouplings, pose: pyrosetta.rosetta.core.pose.Pose, ptask: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: protocols::dna::WatsonCrickRotamerCouplings::apply(const class core::pose::Pose &, class core::pack::task::PackerTask &) const –> void

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

clone(self: pyrosetta.rosetta.protocols.dna.WatsonCrickRotamerCouplings) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::dna::WatsonCrickRotamerCouplings::clone() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

static keyname() → str¶: C++: protocols::dna::WatsonCrickRotamerCouplings::keyname() –> std::string

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

provide_citation_info(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperation, : 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 task operations wishing to provide citation information.

C++: core::pack::task::operation::TaskOperation::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

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

class pyrosetta.rosetta.protocols.dna.WatsonCrickRotamerCouplingsCreator¶

Bases: TaskOperationCreator

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

create_task_operation(self: pyrosetta.rosetta.protocols.dna.WatsonCrickRotamerCouplingsCreator) → pyrosetta.rosetta.core.pack.task.operation.TaskOperation¶: C++: protocols::dna::WatsonCrickRotamerCouplingsCreator::create_task_operation() const –> class std::shared_ptr<class core::pack::task::operation::TaskOperation>

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

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

skip_citation_info_in_schema(self: pyrosetta.rosetta.core.pack.task.operation.TaskOperationCreator) → bool¶

Indicate whether we skip adding citation information to the XML schema.

False for any real task operation. True only for dummy task operations created for unit tests.

C++: core::pack::task::operation::TaskOperationCreator::skip_citation_info_in_schema() const –> bool

pyrosetta.rosetta.protocols.dna.add_constraints_from_file(pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::dna::add_constraints_from_file(class core::pose::Pose &) –> void

pyrosetta.rosetta.protocols.dna.argrot_dna_dis2(*args, **kwargs)¶

Overloaded function.

argrot_dna_dis2(pose: pyrosetta.rosetta.core.pose.Pose, presid: int, pres: pyrosetta.rosetta.core.conformation.Residue, dres: pyrosetta.rosetta.core.conformation.Residue, threshold: float) -> float
argrot_dna_dis2(pose: pyrosetta.rosetta.core.pose.Pose, presid: int, pres: pyrosetta.rosetta.core.conformation.Residue, dres: pyrosetta.rosetta.core.conformation.Residue, threshold: float, base_only: bool) -> float

arginine rotamer sweep at a protein residue to see if it should be considered a (potentially) ‘dna-contacting’ residue

ashworth

C++: protocols::dna::argrot_dna_dis2(const class core::pose::Pose &, unsigned long, const class core::conformation::Residue &, const class core::conformation::Residue &, double, bool) –> double

pyrosetta.rosetta.protocols.dna.checkpoint_cleanup() → None¶: C++: protocols::dna::checkpoint_cleanup() –> void

pyrosetta.rosetta.protocols.dna.close_to_dna(*args, **kwargs)¶

Overloaded function.

close_to_dna(pres: pyrosetta.rosetta.core.conformation.Residue, dres: pyrosetta.rosetta.core.conformation.Residue, cut2: float) -> bool
close_to_dna(pres: pyrosetta.rosetta.core.conformation.Residue, dres: pyrosetta.rosetta.core.conformation.Residue, cut2: float, base_only: bool) -> bool

checks c-beta (except glycine) to base atom-atom distances, not including ribose or phosphate backbone.

ashworth

C++: protocols::dna::close_to_dna(const class core::conformation::Residue &, const class core::conformation::Residue &, double, bool) –> bool

pyrosetta.rosetta.protocols.dna.dna_base_partner(na: pyrosetta.rosetta.core.chemical.AA) → pyrosetta.rosetta.core.chemical.AA¶: C++: protocols::dna::dna_base_partner(const enum core::chemical::AA &) –> enum core::chemical::AA

pyrosetta.rosetta.protocols.dna.dna_comp_name_str(dna: str) → str¶

also consider using the dna_base_partner function below

ashworth

C++: protocols::dna::dna_comp_name_str(const std::string &) –> std::string

pyrosetta.rosetta.protocols.dna.dna_full_name3(name3: str) → str¶

intended to convert any DNA “threeletter code” into the full three-letter code. Note that this does not (necessarily) return the same thing as residue_type::name3 (which returns ” N” format as of Dec 2008)

C++: protocols::dna::dna_full_name3(const std::string &) –> std::string

pyrosetta.rosetta.protocols.dna.find_basepairs(*args, **kwargs)¶

Overloaded function.

find_basepairs(pose: pyrosetta.rosetta.core.pose.Pose, dna_chains: pyrosetta.rosetta.protocols.dna.DnaChains) -> None
find_basepairs(pose: pyrosetta.rosetta.core.pose.Pose, dna_chains: pyrosetta.rosetta.protocols.dna.DnaChains, include_unpaired: bool) -> None

DnaChains version, adapted from pbradley’s code. More paranoid geometry checks, in order to allow highly distorted basepairs without making mistakes

ashworth

C++: protocols::dna::find_basepairs(const class core::pose::Pose &, class protocols::dna::DnaChains &, bool) –> void

pyrosetta.rosetta.protocols.dna.load_checkpoint(pose: pyrosetta.rosetta.core.pose.Pose, iter: int) → None¶: C++: protocols::dna::load_checkpoint(class core::pose::Pose &, unsigned long &) –> void

pyrosetta.rosetta.protocols.dna.load_dna_design_defs_from_file(defs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t, filename: str, pdb_prefix: str) → None¶: C++: protocols::dna::load_dna_design_defs_from_file(class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &, const std::string &, const std::string &) –> void

pyrosetta.rosetta.protocols.dna.load_dna_design_defs_from_options(*args, **kwargs)¶

Overloaded function.

load_dna_design_defs_from_options(defs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t) -> None
load_dna_design_defs_from_options(defs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t, pdb_prefix: str) -> None

C++: protocols::dna::load_dna_design_defs_from_options(class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &, const std::string &) –> void

pyrosetta.rosetta.protocols.dna.load_dna_design_defs_from_strings(defs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_dna_DnaDesignDef_t, str_defs: pyrosetta.rosetta.utility.vector1_std_string) → None¶

loads command-line dna design definitions (shorthand alternative to using resfile)

option value is string vector: i.e. -dna_defs C.-6 C.-5 or -dna_defs C.-6.GUA C.-5.CYT

ashworth

C++: protocols::dna::load_dna_design_defs_from_strings(class utility::vector1<class std::shared_ptr<class protocols::dna::DnaDesignDef>, class std::allocator<class std::shared_ptr<class protocols::dna::DnaDesignDef> > > &, const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

pyrosetta.rosetta.protocols.dna.make_base_pair_aware_fold_tree(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.kinematics.FoldTree¶: C++: protocols::dna::make_base_pair_aware_fold_tree(const class core::pose::Pose &) –> class core::kinematics::FoldTree

pyrosetta.rosetta.protocols.dna.make_single_mutants(sequence: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t, ptask: pyrosetta.rosetta.core.pack.task.PackerTask, sequences: pyrosetta.rosetta.utility.vector1_std_map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_std_less_unsigned_long_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t) → None¶

make a list of all single mutants from a base sequence

ashworth

C++: protocols::dna::make_single_mutants(const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > &, class std::shared_ptr<const class core::pack::task::PackerTask>, class utility::vector1<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, class std::allocator<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > > > &) –> void

pyrosetta.rosetta.protocols.dna.make_subdirs(: str) → None¶: C++: protocols::dna::make_subdirs(const std::string &) –> void

pyrosetta.rosetta.protocols.dna.not_already_connected(pose: pyrosetta.rosetta.core.pose.Pose, num_jumps: int, this_chain: str, other_chain: str, jump_pairs: pyrosetta.rosetta.ObjexxFCL.FArray2D_unsigned_long_t) → bool¶: C++: protocols::dna::not_already_connected(const class core::pose::Pose &, const unsigned long, const char, const char, class ObjexxFCL::FArray2D<unsigned long> &) –> bool

pyrosetta.rosetta.protocols.dna.print_sequence_pdb_nums(: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::dna::print_sequence_pdb_nums(const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > &, const class core::pose::Pose &, std::ostream &) –> void

pyrosetta.rosetta.protocols.dna.print_sequences_pdb_nums(: pyrosetta.rosetta.utility.vector1_std_map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_std_less_unsigned_long_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::dna::print_sequences_pdb_nums(const class utility::vector1<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > >, class std::allocator<class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > > > &, const class core::pose::Pose &, std::ostream &) –> void

pyrosetta.rosetta.protocols.dna.restrict_dna_rotamers(rotsets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, seq: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t, rot_to_pack: pyrosetta.rosetta.utility.vector0_int) → None¶

for packing a single DNA sequence out of a multi-DNA-sequence RotamerSet

ashworth

C++: protocols::dna::restrict_dna_rotamers(class std::shared_ptr<const class core::pack::rotamer_set::RotamerSets>, const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > &, class utility::vector0<int, class std::allocator<int> > &) –> void

pyrosetta.rosetta.protocols.dna.restrict_to_single_sequence(rotamer_sets: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSets, single_sequence: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_chemical_ResidueType_t, rot_to_pack: pyrosetta.rosetta.utility.vector0_int) → None¶

for packing a single sequence out of a RotamerSets that (potentially) represents sequence variability

ashworth

C++: protocols::dna::restrict_to_single_sequence(class std::shared_ptr<const class core::pack::rotamer_set::RotamerSets>, const class utility::vector1<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &, class utility::vector0<int, class std::allocator<int> > &) –> void

pyrosetta.rosetta.protocols.dna.seq_pdb_str(: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t, : pyrosetta.rosetta.core.pose.Pose) → str¶: C++: protocols::dna::seq_pdb_str(const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > &, const class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.dna.seq_to_str(seq: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_const_core_chemical_ResidueType_t) → str¶: C++: protocols::dna::seq_to_str(const class std::map<unsigned long, class std::shared_ptr<const class core::chemical::ResidueType>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class core::chemical::ResidueType> > > > &) –> std::string

pyrosetta.rosetta.protocols.dna.set_base_segment_chainbreak_constraints(pose: pyrosetta.rosetta.core.pose.Pose, this_base: int, end_base: int) → None¶: C++: protocols::dna::set_base_segment_chainbreak_constraints(class core::pose::Pose &, const unsigned long, const unsigned long) –> void

pyrosetta.rosetta.protocols.dna.show_dna_geometry(pose: pyrosetta.rosetta.core.pose.Pose, out: pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::dna::show_dna_geometry(const class core::pose::Pose &, std::ostream &) –> void

pyrosetta.rosetta.protocols.dna.show_dna_geometry_extra_details(pose: pyrosetta.rosetta.core.pose.Pose, tag: str, out: pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::dna::show_dna_geometry_extra_details(const class core::pose::Pose &, std::string, std::ostream &) –> void

pyrosetta.rosetta.protocols.dna.substitute_residue(pose: pyrosetta.rosetta.core.pose.Pose, index: int, new_type: pyrosetta.rosetta.core.chemical.ResidueType) → None¶: C++: protocols::dna::substitute_residue(class core::pose::Pose &, unsigned long, const class core::chemical::ResidueType &) –> void

pyrosetta.rosetta.protocols.dna.write_checkpoint(pose: pyrosetta.rosetta.core.pose.Pose, iter: int) → None¶: C++: protocols::dna::write_checkpoint(class core::pose::Pose &, unsigned long) –> void

pyrosetta.rosetta.protocols.dna.z_axis_dist(pres: pyrosetta.rosetta.core.conformation.Residue, dres: pyrosetta.rosetta.core.conformation.Residue) → float¶

A sanity check for the arginine rotamer screen. Can prevent the design of positions that are best left alone because they are too far away along the helical axis (‘laterally’).

ashworth

C++: protocols::dna::z_axis_dist(const class core::conformation::Residue &, const class core::conformation::Residue &) –> double