hashing

Bindings for protocols::sewing::hashing namespace

class pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFGMSettings

Bases: pybind11_builtins.pybind11_object

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFGMSettings, : pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFGMSettings) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFGMSettings

C++: protocols::sewing::hashing::AlignmentFGMSettings::operator=(const struct protocols::sewing::hashing::AlignmentFGMSettings &) –> struct protocols::sewing::hashing::AlignmentFGMSettings &

property match_segments
property pose_segment_ends
property pose_segment_starts
property recursive_depth
class pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

Given a model file, edge file ,and one or more input structures, generates alignment files for use with AppendAssemblyMover.

static add_pose_segments_to_segment_vector(*args, **kwargs)

Overloaded function.

  1. add_pose_segments_to_segment_vector(pose: pyrosetta.rosetta.core.pose.Pose, partner_pose: pyrosetta.rosetta.core.pose.Pose, segvec: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector, pdb_segments: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, pose_segment_starts_string: str, pose_segment_ends_string: str, pose_segment_dssp: str, ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription, partner_ligands: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_protocols_sewing_data_storage_LigandResidue_t, expanded_ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription, required_resnums: str, required_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, strict_dssp_changes: bool) -> int

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::add_pose_segments_to_segment_vector(const class core::pose::Pose &, class std::shared_ptr<class core::pose::Pose>, class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>, class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &, std::string, std::string, std::string, class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &, class std::map<unsigned long, class std::shared_ptr<const class protocols::sewing::data_storage::LigandResidue>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class protocols::sewing::data_storage::LigandResidue> > > > &, class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, bool) –> unsigned long

  1. add_pose_segments_to_segment_vector(pose: pyrosetta.rosetta.core.pose.Pose, partner_pose: pyrosetta.rosetta.core.pose.Pose, bmg: protocols::sewing::hashing::BasisMapGenerator, ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription, partner_ligands: pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_const_protocols_sewing_data_storage_LigandResidue_t, expanded_ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription, required_resnums: str, required_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector, set_segments_from_dssp: bool) -> int

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::add_pose_segments_to_segment_vector(const class core::pose::Pose &, class std::shared_ptr<class core::pose::Pose>, class std::shared_ptr<class protocols::sewing::hashing::BasisMapGenerator>, class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &, class std::map<unsigned long, class std::shared_ptr<const class protocols::sewing::data_storage::LigandResidue>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<const class protocols::sewing::data_storage::LigandResidue> > > > &, class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &, std::string, class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>, bool) –> unsigned long

static alignment_settings_from_tag(tag: pyrosetta.rosetta.utility.tag.Tag) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFGMSettings

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::alignment_settings_from_tag(class std::shared_ptr<const class utility::tag::Tag>) –> class std::shared_ptr<struct protocols::sewing::hashing::AlignmentFGMSettings>

static append_ligands_subelement(subs: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, include_coord: bool) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::append_ligands_subelement(class utility::tag::XMLSchemaSimpleSubelementList &, class utility::tag::XMLSchemaDefinition &, bool) –> void

apply(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, : pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::operator=(const class protocols::sewing::hashing::AlignmentFileGeneratorMover &) –> class protocols::sewing::hashing::AlignmentFileGeneratorMover &

static basis_map_from_alignment(alignment: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFGMSettings, pose: pyrosetta.rosetta.core.pose.Pose, bmg: protocols::sewing::hashing::BasisMapGenerator) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::basis_map_from_alignment(const struct protocols::sewing::hashing::AlignmentFGMSettings &, const class core::pose::Pose &, class std::shared_ptr<class protocols::sewing::hashing::BasisMapGenerator>) –> void

basis_map_generator(*args, **kwargs)

Overloaded function.

  1. basis_map_generator(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover) -> protocols::sewing::hashing::BasisMapGenerator

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::basis_map_generator() const –> class std::shared_ptr<class protocols::sewing::hashing::BasisMapGenerator>

  1. basis_map_generator(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, bmg: protocols::sewing::hashing::BasisMapGenerator) -> None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::basis_map_generator(class std::shared_ptr<class protocols::sewing::hashing::BasisMapGenerator>) –> void

static class_name() str

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::class_name() –> std::string

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.sewing.hashing.AlignmentFileGeneratorMover) pyrosetta.rosetta.protocols.moves.Mover

required in the context of the parser/scripting scheme

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::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.sewing.hashing.AlignmentFileGeneratorMover) pyrosetta.rosetta.protocols.moves.Mover

required in the context of the parser/scripting scheme

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::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.sewing.hashing.AlignmentFileGeneratorMover) str

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::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_required_resnums(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover) str

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::get_required_resnums() const –> std::string

get_required_selector(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover) pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::get_required_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

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 ligands_subtag_ct_namer(: str) str

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::ligands_subtag_ct_namer(std::string) –> std::string

static name() str

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

static parse_ligand_conformers(ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::parse_ligand_conformers(class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &) –> void

static parse_ligands_tag(ligands_tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::parse_ligands_tag(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &, class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) None

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

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::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: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::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_required_resnums(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, : str) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::set_required_resnums(std::string) –> void

set_required_selector(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, : pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::set_required_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

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

Set the ‘type’ string

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

show(*args, **kwargs)

Overloaded function.

  1. show(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover) -> None

  2. show(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover, output: pyrosetta.rosetta.std.ostream) -> None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMover::show(std::ostream &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) None
: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

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

type(*args, **kwargs)

Overloaded function.

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

Set the ‘type’ string

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

  1. 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.sewing.hashing.AlignmentFileGeneratorMoverCreator

Bases: pyrosetta.rosetta.protocols.moves.MoverCreator

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMoverCreator, : pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMoverCreator) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMoverCreator

C++: protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator::operator=(const class protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator &) –> class protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator &

create_mover(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMoverCreator) pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator::create_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

keyname(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMoverCreator) str

C++: protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator::keyname() const –> std::string

static mover_name() str

C++: protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator::mover_name() –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMoverCreator, : pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) None

C++: protocols::sewing::hashing::AlignmentFileGeneratorMoverCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator

Bases: pybind11_builtins.pybind11_object

This class contains the infrastructure for parsing an edge file and for generating all possible alignments for a given edge.

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator, : pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator

C++: protocols::sewing::hashing::AlignmentGenerator::operator=(const class protocols::sewing::hashing::AlignmentGenerator &) –> class protocols::sewing::hashing::AlignmentGenerator &

clone(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator

C++: protocols::sewing::hashing::AlignmentGenerator::clone() const –> class std::shared_ptr<class protocols::sewing::hashing::AlignmentGenerator>

const_pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::AlignmentGenerator::const_pdb_segments() const –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > >

get_all_alignments(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator, s1: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, s2: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment) pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

Determines all possible basis pairs for an edge given the two SewSegments involved.

C++: protocols::sewing::hashing::AlignmentGenerator::get_all_alignments(class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>) –> class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

hasher_settings(*args, **kwargs)

Overloaded function.

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings

C++: protocols::sewing::hashing::AlignmentGenerator::hasher_settings() const –> struct protocols::sewing::hashing::HasherSettings

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator, hs: pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings) -> None

C++: protocols::sewing::hashing::AlignmentGenerator::hasher_settings(struct protocols::sewing::hashing::HasherSettings &) –> void

pdb_segments(*args, **kwargs)

Overloaded function.

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::AlignmentGenerator::pdb_segments() –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) -> None

C++: protocols::sewing::hashing::AlignmentGenerator::pdb_segments(class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &) –> void

segment_vector(*args, **kwargs)

Overloaded function.

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

C++: protocols::sewing::hashing::AlignmentGenerator::segment_vector() const –> class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator, segvec: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector) -> None

C++: protocols::sewing::hashing::AlignmentGenerator::segment_vector(class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>) –> void

class pyrosetta.rosetta.protocols.sewing.hashing.AlignmentSettings

Bases: pybind11_builtins.pybind11_object

////////////// Begin AlignmentSettings ///////////////////

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentSettings, : pyrosetta.rosetta.protocols.sewing.hashing.AlignmentSettings) pyrosetta.rosetta.protocols.sewing.hashing.AlignmentSettings

C++: protocols::sewing::hashing::AlignmentSettings::operator=(const struct protocols::sewing::hashing::AlignmentSettings &) –> struct protocols::sewing::hashing::AlignmentSettings &

property match_segments_
property recursive_depth_
property segments_
class pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator

Bases: pybind11_builtins.pybind11_object

Given a model file, edge file ,and one or more input structures, generates alignment files for use with AppendAssemblyMover.

alignment_generator(*args, **kwargs)

Overloaded function.

  1. alignment_generator(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator

C++: protocols::sewing::hashing::BasisMapGenerator::alignment_generator() const –> class std::shared_ptr<class protocols::sewing::hashing::AlignmentGenerator>

  1. alignment_generator(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, ag: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::alignment_generator(class std::shared_ptr<class protocols::sewing::hashing::AlignmentGenerator>) –> void

alignment_settings(*args, **kwargs)

Overloaded function.

  1. alignment_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.AlignmentSettings

C++: protocols::sewing::hashing::BasisMapGenerator::alignment_settings() const –> struct protocols::sewing::hashing::AlignmentSettings

  1. alignment_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, as: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentSettings) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::alignment_settings(struct protocols::sewing::hashing::AlignmentSettings &) –> void

alignment_settings_from_options(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) None

C++: protocols::sewing::hashing::BasisMapGenerator::alignment_settings_from_options() –> void

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, : pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator

C++: protocols::sewing::hashing::BasisMapGenerator::operator=(const class protocols::sewing::hashing::BasisMapGenerator &) –> class protocols::sewing::hashing::BasisMapGenerator &

basis_map(*args, **kwargs)

Overloaded function.

  1. basis_map(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> std::map<unsigned long, std::map<unsigned long, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > > > > >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::map<unsigned long, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > > > > > > > >

C++: protocols::sewing::hashing::BasisMapGenerator::basis_map() const –> class std::shared_ptr<class std::map<unsigned long, class std::map<unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > > > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > > > > > > > >

  1. basis_map(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, bm: std::map<unsigned long, std::map<unsigned long, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > > > > >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::map<unsigned long, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > > > > > > > >) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::basis_map(class std::shared_ptr<class std::map<unsigned long, class std::map<unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > > > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::map<unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > > > > > > > >) –> void

basis_pair_is_valid(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, basis_pair: Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.Basis, pyrosetta.rosetta.protocols.sewing.data_storage.Basis], first_is_N: bool) bool

Checks that the given basis pair exists in the BasisMap after calling recurse_over_segments on seg1

Must be called for original segment IDs (no chimaerae or segment duplicates)

C++: protocols::sewing::hashing::BasisMapGenerator::basis_pair_is_valid(struct std::pair<class protocols::sewing::data_storage::Basis, class protocols::sewing::data_storage::Basis>, bool) –> bool

clone(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator

required in the context of the parser/scripting scheme

C++: protocols::sewing::hashing::BasisMapGenerator::clone() const –> class std::shared_ptr<class protocols::sewing::hashing::BasisMapGenerator>

const_pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::BasisMapGenerator::const_pdb_segments() const –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > >

delete_segment_basis_pairs(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, : int) None

C++: protocols::sewing::hashing::BasisMapGenerator::delete_segment_basis_pairs(unsigned long) –> void

edge_file_from_options(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) None

C++: protocols::sewing::hashing::BasisMapGenerator::edge_file_from_options() –> void

edge_file_reader(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) protocols::sewing::hashing::EdgeMapGenerator

C++: protocols::sewing::hashing::BasisMapGenerator::edge_file_reader() const –> class std::shared_ptr<class protocols::sewing::hashing::EdgeMapGenerator>

get_basis_pair_for_local_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, seg1: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, seg2: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, first_is_N: bool) Tuple[bool, Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.Basis, pyrosetta.rosetta.protocols.sewing.data_storage.Basis]]

This function wraps several of the functions below to retrieve a basis pair for local (possibly chimaeric) input segments.

This function first calls segs_can_chimerize to determine whether the segments can ever chimerize

It then retrieves the basis residue bounds for the two segmnets If seg1 (or seg2) is chimaeric, it gets the appropriate parent to use for finding a basis pair. It also handles all conversions between parent and chimaeric residue numbering It has 1000 chances to choose a valid basis pair for the chimaera that fits within the residue bounds If it hasn’t found something by then, it just gives up

C++: protocols::sewing::hashing::BasisMapGenerator::get_basis_pair_for_local_segments(class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, bool) –> struct std::pair<bool, struct std::pair<class protocols::sewing::data_storage::Basis, class protocols::sewing::data_storage::Basis> >

get_basis_pair_for_segment(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, segment_id: int) Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.Basis, pyrosetta.rosetta.protocols.sewing.data_storage.Basis]

Given a segmentID, return a randomly chosen basis pair from the BasisMap for this segment

C++: protocols::sewing::hashing::BasisMapGenerator::get_basis_pair_for_segment(unsigned long) –> struct std::pair<class protocols::sewing::data_storage::Basis, class protocols::sewing::data_storage::Basis>

get_basis_pair_for_segment_pair(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, seg1: int, seg2: int, first_is_N: bool) Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.Basis, pyrosetta.rosetta.protocols.sewing.data_storage.Basis]

Given two (original, non-chimaeric) segments, return a possible basis pair for those two segments.

Does not take chimaeric basis residue bounds into account; currently we handle those by first checking

if the chimaeric segment can chimerize with the partner and then call this repeatedly until we get something that works

C++: protocols::sewing::hashing::BasisMapGenerator::get_basis_pair_for_segment_pair(unsigned long, unsigned long, bool) –> struct std::pair<class protocols::sewing::data_storage::Basis, class protocols::sewing::data_storage::Basis>

get_basis_res_bounds(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, seg1: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, seg2: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, first_is_N: bool) Tuple[Tuple[int, int], Tuple[int, int]]

Given two (possibly chimaeric) segments, return ranges of valid basis residues for each

Accounds for both chimaeric basis residues and vital residues. Returns pairs (resnum ranges) in

the same order that the segments were provided.

C++: protocols::sewing::hashing::BasisMapGenerator::get_basis_res_bounds(class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, bool) –> struct std::pair<struct std::pair<unsigned long, unsigned long>, struct std::pair<unsigned long, unsigned long> >

hasher_settings(*args, **kwargs)

Overloaded function.

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings

C++: protocols::sewing::hashing::BasisMapGenerator::hasher_settings() const –> struct protocols::sewing::hashing::HasherSettings

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, hs: pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::hasher_settings(struct protocols::sewing::hashing::HasherSettings &) –> void

initialize_from_options(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) None

C++: protocols::sewing::hashing::BasisMapGenerator::initialize_from_options() –> void

model_file_from_options(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) None

C++: protocols::sewing::hashing::BasisMapGenerator::model_file_from_options() –> void

pdb_segments(*args, **kwargs)

Overloaded function.

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::BasisMapGenerator::pdb_segments() –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::pdb_segments(class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > >) –> void

read_alignments_from_file(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, file_name: str) None

C++: protocols::sewing::hashing::BasisMapGenerator::read_alignments_from_file(std::string) –> void

segment_vector(*args, **kwargs)

Overloaded function.

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

C++: protocols::sewing::hashing::BasisMapGenerator::segment_vector() const –> class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, segvec: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::segment_vector(class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>) –> void

segs_can_chimerize(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, seg1: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, seg2: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, first_is_N: bool) Tuple[bool, bool]

Checks that a pair of segments (including chimaerae!) can chimerize.

First bool indicates whether seg1 can ever be chimerized with ANYTHING;

second indicates if it can chimerize with seg2 specifically. Calls get_basis_res_bounds to handle chimaera( only checks on the correct terminal-side of the old basis res for chimaerae

C++: protocols::sewing::hashing::BasisMapGenerator::segs_can_chimerize(class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, bool) –> struct std::pair<bool, bool>

set_alignment_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, match_segments: pyrosetta.rosetta.utility.vector1_unsigned_long, pose_segment_starts: pyrosetta.rosetta.utility.vector1_unsigned_long, pose_segment_ends: pyrosetta.rosetta.utility.vector1_unsigned_long, recursive_depth: int) None

C++: protocols::sewing::hashing::BasisMapGenerator::set_alignment_settings(class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, unsigned long) –> void

set_edge_file(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, edge_file: str) None

C++: protocols::sewing::hashing::BasisMapGenerator::set_edge_file(std::string) –> void

set_edge_file_reader(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, edge_file_reader: protocols::sewing::hashing::EdgeMapGenerator) None

C++: protocols::sewing::hashing::BasisMapGenerator::set_edge_file_reader(class std::shared_ptr<class protocols::sewing::hashing::EdgeMapGenerator>) –> void

set_model_file(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, model_file_name: str) None

C++: protocols::sewing::hashing::BasisMapGenerator::set_model_file(std::string) –> void

set_private_data(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, model_file_name: str, edge_file_name: str, match_segments: pyrosetta.rosetta.utility.vector1_unsigned_long, pose_segment_starts: pyrosetta.rosetta.utility.vector1_unsigned_long, pose_segment_ends: pyrosetta.rosetta.utility.vector1_unsigned_long, recursive_depth: int) None

C++: protocols::sewing::hashing::BasisMapGenerator::set_private_data(std::string, std::string, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, unsigned long) –> void

version(*args, **kwargs)

Overloaded function.

  1. version(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> int

C++: protocols::sewing::hashing::BasisMapGenerator::version() const –> unsigned long

  1. version(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, ver: int) -> None

C++: protocols::sewing::hashing::BasisMapGenerator::version(unsigned long) –> void

write_alignments_to_file(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, file_name: str) None

C++: protocols::sewing::hashing::BasisMapGenerator::write_alignments_to_file(std::string) const –> void

class pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator

Bases: pybind11_builtins.pybind11_object

Class used to generate and load in edge files for use with SEWING protocols.

append_to_edge_map(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, base_seg_id: int) None

Used to add a given segment’s n-most and c-most terminal segments to EdgeMap

C++: protocols::sewing::hashing::EdgeMapGenerator::append_to_edge_map(unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, : pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator

C++: protocols::sewing::hashing::EdgeMapGenerator::operator=(const class protocols::sewing::hashing::EdgeMapGenerator &) –> class protocols::sewing::hashing::EdgeMapGenerator &

clone(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator

C++: protocols::sewing::hashing::EdgeMapGenerator::clone() –> class std::shared_ptr<class protocols::sewing::hashing::EdgeMapGenerator>

const_pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::EdgeMapGenerator::const_pdb_segments() const –> const class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > >

edge_exists(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, seg1: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, seg2: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, hasher: protocols::sewing::hashing::Hasher) bool

Check whether two SewSegments can form an edge.

C++: protocols::sewing::hashing::EdgeMapGenerator::edge_exists(class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<class protocols::sewing::hashing::Hasher>) –> bool

edge_file_name(*args, **kwargs)

Overloaded function.

  1. edge_file_name(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) -> str

C++: protocols::sewing::hashing::EdgeMapGenerator::edge_file_name() const –> std::string

  1. edge_file_name(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, name: str) -> None

C++: protocols::sewing::hashing::EdgeMapGenerator::edge_file_name(std::string) –> void

edge_map(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) std::map<unsigned long, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long> >, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long> > > > >

C++: protocols::sewing::hashing::EdgeMapGenerator::edge_map() const –> class std::shared_ptr<class std::map<unsigned long, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > > > > >

generate_edge_file(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) None

Main method of this class that is responsible for dividing work between nodes and iterating over models

C++: protocols::sewing::hashing::EdgeMapGenerator::generate_edge_file() –> void

get_terminal_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) Tuple[pyrosetta.rosetta.utility.vector1_unsigned_long, pyrosetta.rosetta.utility.vector1_unsigned_long]

Generate vectors of IDs of N-terminal and C-terminal segments

C++: protocols::sewing::hashing::EdgeMapGenerator::get_terminal_segments() –> struct std::pair<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> > >

hasher_settings(*args, **kwargs)

Overloaded function.

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings

C++: protocols::sewing::hashing::EdgeMapGenerator::hasher_settings() const –> struct protocols::sewing::hashing::HasherSettings

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, hs: pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings) -> None

C++: protocols::sewing::hashing::EdgeMapGenerator::hasher_settings(struct protocols::sewing::hashing::HasherSettings &) –> void

initialize_from_options(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) None

Get values of command-line options

C++: protocols::sewing::hashing::EdgeMapGenerator::initialize_from_options() –> void

is_edge_file_loaded(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) bool

C++: protocols::sewing::hashing::EdgeMapGenerator::is_edge_file_loaded() const –> bool

load_edge_file(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, edge_file_name: str) None

Main function for reading edge files (sets values of other member variables)

C++: protocols::sewing::hashing::EdgeMapGenerator::load_edge_file(std::string) –> void

pdb_segments(*args, **kwargs)

Overloaded function.

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::EdgeMapGenerator::pdb_segments() –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) -> None

C++: protocols::sewing::hashing::EdgeMapGenerator::pdb_segments(class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &) –> void

read_edge_file(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) None

Alternate function to read edge file when name is already known

C++: protocols::sewing::hashing::EdgeMapGenerator::read_edge_file() –> void

segment_vector(*args, **kwargs)

Overloaded function.

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) -> pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

C++: protocols::sewing::hashing::EdgeMapGenerator::segment_vector() const –> class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, segvector: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector) -> None

C++: protocols::sewing::hashing::EdgeMapGenerator::segment_vector(class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>) –> void

set_private_data(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, model_file_name: str, boxes_per_dimension: int, min_hash_score: int, max_clash_score: int, hash_opposite_termini: bool) None

Shared setup of private data members

C++: protocols::sewing::hashing::EdgeMapGenerator::set_private_data(std::string, unsigned long, unsigned long, unsigned long, bool) –> void

version(*args, **kwargs)

Overloaded function.

  1. version(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) -> int

C++: protocols::sewing::hashing::EdgeMapGenerator::version() const –> unsigned long

  1. version(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, ver: int) -> None

C++: protocols::sewing::hashing::EdgeMapGenerator::version(unsigned long) –> void

write_edges_for_segment(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, current_n_segment: int, hasher: protocols::sewing::hashing::Hasher, output_file: pyrosetta.rosetta.std.ostream, c_segs: pyrosetta.rosetta.utility.vector1_unsigned_long) None

Method called by each individual processor to write to its edge file

C++: protocols::sewing::hashing::EdgeMapGenerator::write_edges_for_segment(unsigned long, class std::shared_ptr<class protocols::sewing::hashing::Hasher>, std::ostream &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

class pyrosetta.rosetta.protocols.sewing.hashing.HashValue

Bases: pybind11_builtins.pybind11_object

property atomno
property basis_resnum
property basis_segment_id
property resnum
property segment_id
class pyrosetta.rosetta.protocols.sewing.hashing.Hasher

Bases: pybind11_builtins.pybind11_object

A geometric hashing class used by the SEWING protocol

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, : pyrosetta.rosetta.protocols.sewing.hashing.Hasher) pyrosetta.rosetta.protocols.sewing.hashing.Hasher

C++: protocols::sewing::hashing::Hasher::operator=(const class protocols::sewing::hashing::Hasher &) –> class protocols::sewing::hashing::Hasher &

can_hash(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, seg1: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, seg2: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment) bool

C++: protocols::sewing::hashing::Hasher::can_hash(class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>, class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>) –> bool

clone(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) pyrosetta.rosetta.protocols.sewing.hashing.Hasher

C++: protocols::sewing::hashing::Hasher::clone() const –> class std::shared_ptr<class protocols::sewing::hashing::Hasher>

const_pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::Hasher::const_pdb_segments() const –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > >

generate_key(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, atom: pyrosetta.rosetta.core.conformation.Atom) pyrosetta.rosetta.utility.fixedsizearray1_int_3_t

creates key for HashMap

C++: protocols::sewing::hashing::Hasher::generate_key(const class core::conformation::Atom &) const –> class utility::fixedsizearray1<int, 3>

get_hash_map_size(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) int

C++: protocols::sewing::hashing::Hasher::get_hash_map_size() const –> unsigned long

get_seg1(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment

C++: protocols::sewing::hashing::Hasher::get_seg1() const –> class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>

get_seg2(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment

C++: protocols::sewing::hashing::Hasher::get_seg2() const –> class std::shared_ptr<const class protocols::sewing::data_storage::SmartSegment>

hash_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, transformed_segment: pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, basis_residue: pyrosetta.rosetta.protocols.sewing.data_storage.Basis) None

adds segments to the hash_map, excluding the basis residue from being scored.

C++: protocols::sewing::hashing::Hasher::hash_segments(const class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, const class protocols::sewing::data_storage::Basis &) –> void

hasher_settings(*args, **kwargs)

Overloaded function.

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) -> pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings

C++: protocols::sewing::hashing::Hasher::hasher_settings() const –> struct protocols::sewing::hashing::HasherSettings

  1. hasher_settings(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, hasher_settings: pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings) -> None

C++: protocols::sewing::hashing::Hasher::hasher_settings(const struct protocols::sewing::hashing::HasherSettings &) –> void

initialize_from_options(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) None

C++: protocols::sewing::hashing::Hasher::initialize_from_options() –> void

initialize_hashmap(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, basis_pair: Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.Basis, pyrosetta.rosetta.protocols.sewing.data_storage.Basis]) pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment

Returns a transformed segments that will be scored against the model currently in the HashMap.

C++: protocols::sewing::hashing::Hasher::initialize_hashmap(const struct std::pair<class protocols::sewing::data_storage::Basis, class protocols::sewing::data_storage::Basis> &) –> class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>

pdb_segments(*args, **kwargs)

Overloaded function.

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

C++: protocols::sewing::hashing::Hasher::pdb_segments() –> class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &

  1. pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) -> None

C++: protocols::sewing::hashing::Hasher::pdb_segments(class std::map<unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment> > > > &) –> void

score_basis_pair(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, basis_pair: Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.Basis, pyrosetta.rosetta.protocols.sewing.data_storage.Basis]) bool

returns whether the basis pair meets edge requirements for max_clash and min_hash_score

C++: protocols::sewing::hashing::Hasher::score_basis_pair(const struct std::pair<class protocols::sewing::data_storage::Basis, class protocols::sewing::data_storage::Basis> &) –> bool

segment_vector(*args, **kwargs)

Overloaded function.

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) -> pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

C++: protocols::sewing::hashing::Hasher::segment_vector() const –> class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>

  1. segment_vector(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, segment_vector: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector) -> None

C++: protocols::sewing::hashing::Hasher::segment_vector(class std::shared_ptr<const class protocols::sewing::hashing::SegmentVector>) –> void

transform_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, current_basis: pyrosetta.rosetta.protocols.sewing.data_storage.Basis, first: bool) None

iterates through neighbors of n_terminal segments transforms xyz coordninates into basis_residue coordinate frame.

C++: protocols::sewing::hashing::Hasher::transform_segments(class protocols::sewing::data_storage::Basis, bool) –> void

class pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings

Bases: pybind11_builtins.pybind11_object

/////////////////////// Begin HasherSettings ////////////////////////////////////////

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings, : pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings) pyrosetta.rosetta.protocols.sewing.hashing.HasherSettings

C++: protocols::sewing::hashing::HasherSettings::operator=(const struct protocols::sewing::hashing::HasherSettings &) –> struct protocols::sewing::hashing::HasherSettings &

property boxes_per_dimension
property hash_between_termini
property max_clash_score
property min_hash_score
class pyrosetta.rosetta.protocols.sewing.hashing.IdealContact

Bases: pybind11_builtins.pybind11_object

property ligand_atom
property max_contacts
property preferred_contact_angle
property preferred_dihedral_1
property preferred_dihedral_2
property preferred_distance
class pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer

Bases: pybind11_builtins.pybind11_object

Given a ligand and an assembly, this class identifies the potential best mutations (with chi angles) to make to add a coordinating residue to the ligand. Another class will test the geometries and make the mutations.

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, : pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer) pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer

C++: protocols::sewing::hashing::LigandBindingResPlacer::operator=(const class protocols::sewing::hashing::LigandBindingResPlacer &) –> class protocols::sewing::hashing::LigandBindingResPlacer &

choose_best_metal_coordinator(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, assembly: pyrosetta.rosetta.protocols.sewing.data_storage.SmartAssembly) Tuple[pyrosetta.rosetta.protocols.sewing.data_storage.SmartSegment, bool]

Finds the best residue/rotamer to coordinate metal (Main function for class)

C++: protocols::sewing::hashing::LigandBindingResPlacer::choose_best_metal_coordinator(class std::shared_ptr<class protocols::sewing::data_storage::SmartAssembly>) –> struct std::pair<class std::shared_ptr<class protocols::sewing::data_storage::SmartSegment>, bool>

contacts_remaining(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer) int

C++: protocols::sewing::hashing::LigandBindingResPlacer::contacts_remaining() const –> unsigned long

static define_ideal_contacts_subelement(subs: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) None

C++: protocols::sewing::hashing::LigandBindingResPlacer::define_ideal_contacts_subelement(class utility::tag::XMLSchemaSimpleSubelementList &, class utility::tag::XMLSchemaDefinition &) –> void

static generate_ligand_key(: pyrosetta.rosetta.numeric.xyzVector_double_t) pyrosetta.rosetta.utility.fixedsizearray1_int_3_t

Generates a HashKey from an xyzVector of core::Real

C++: protocols::sewing::hashing::LigandBindingResPlacer::generate_ligand_key(class numeric::xyzVector<double>) –> class utility::fixedsizearray1<int, 3>

get_best_geometry_score(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer) float

C++: protocols::sewing::hashing::LigandBindingResPlacer::get_best_geometry_score() const –> double

get_geometry_score_weight(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer) float

C++: protocols::sewing::hashing::LigandBindingResPlacer::get_geometry_score_weight() const –> double

get_ligand(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer) protocols::sewing::data_storage::LigandResidue

C++: protocols::sewing::hashing::LigandBindingResPlacer::get_ligand() const –> class std::shared_ptr<class protocols::sewing::data_storage::LigandResidue>

get_possible_coordinations(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer) pyrosetta.rosetta.std.map_std_pair_unsigned_long_unsigned_long_t_std_set_protocols_sewing_hashing_LigandCoordInfo_t

C++: protocols::sewing::hashing::LigandBindingResPlacer::get_possible_coordinations() const –> const class std::map<struct std::pair<unsigned long, unsigned long>, class std::set<struct protocols::sewing::hashing::LigandCoordInfo, struct std::less<struct protocols::sewing::hashing::LigandCoordInfo>, class std::allocator<struct protocols::sewing::hashing::LigandCoordInfo> >, struct std::less<struct std::pair<unsigned long, unsigned long> >, class std::allocator<struct std::pair<const struct std::pair<unsigned long, unsigned long>, class std::set<struct protocols::sewing::hashing::LigandCoordInfo, struct std::less<struct protocols::sewing::hashing::LigandCoordInfo>, class std::allocator<struct protocols::sewing::hashing::LigandCoordInfo> > > > > &

identify_possible_binders(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, assembly: pyrosetta.rosetta.protocols.sewing.data_storage.SmartAssembly) pyrosetta.rosetta.std.map_std_pair_unsigned_long_unsigned_long_t_std_set_protocols_sewing_hashing_LigandCoordInfo_t

First format: Map of (secstruct, map( restype, vector< LigandCoordInfo> ) ) Second format: Map of secstruct to a std::set of zinc HashKeys (generated the same basic way we do in Hasher)

Checks all residue stubs in assembly vs metal coordinates to determine which residues are potentially metal-coordinating. Return a set of SmartSewingResidueOP.

C++: protocols::sewing::hashing::LigandBindingResPlacer::identify_possible_binders(class std::shared_ptr<const class protocols::sewing::data_storage::SmartAssembly>) –> class std::map<struct std::pair<unsigned long, unsigned long>, class std::set<struct protocols::sewing::hashing::LigandCoordInfo, struct std::less<struct protocols::sewing::hashing::LigandCoordInfo>, class std::allocator<struct protocols::sewing::hashing::LigandCoordInfo> >, struct std::less<struct std::pair<unsigned long, unsigned long> >, class std::allocator<struct std::pair<const struct std::pair<unsigned long, unsigned long>, class std::set<struct protocols::sewing::hashing::LigandCoordInfo, struct std::less<struct protocols::sewing::hashing::LigandCoordInfo>, class std::allocator<struct protocols::sewing::hashing::LigandCoordInfo> > > > >

static ligand_subtag_ct_namer(tag: str) str

C++: protocols::sewing::hashing::LigandBindingResPlacer::ligand_subtag_ct_namer(std::string) –> std::string

make_aligned_residue(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, : pyrosetta.rosetta.protocols.sewing.data_storage.SmartSewingResidue, : str) pyrosetta.rosetta.core.conformation.Residue

Convert the ligand atoms’ coordinates into HashKeys Look for the HashKeys in the appropriate HashMap for this DSSP, and compare the atom name to see if it’s a real match If it’s there, add this residue to the map with the corresponding entries from LigandCoordInfo

C++: protocols::sewing::hashing::LigandBindingResPlacer::make_aligned_residue(class std::shared_ptr<class protocols::sewing::data_storage::SmartSewingResidue>, std::string) –> class std::shared_ptr<class core::conformation::Residue>

static parse_ideal_contacts(tag: pyrosetta.rosetta.utility.tag.Tag, ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription) None

C++: protocols::sewing::hashing::LigandBindingResPlacer::parse_ideal_contacts(class std::shared_ptr<const class utility::tag::Tag>, class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &) –> void

static parse_ligand_files(ligands: pyrosetta.rosetta.utility.vector1_protocols_sewing_data_storage_LigandDescription) None

Parses the ligand file format

C++: protocols::sewing::hashing::LigandBindingResPlacer::parse_ligand_files(class utility::vector1<struct protocols::sewing::data_storage::LigandDescription, class std::allocator<struct protocols::sewing::data_storage::LigandDescription> > &) –> void

revert_last_added_contact(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, assembly: pyrosetta.rosetta.protocols.sewing.data_storage.SmartAssembly) None

C++: protocols::sewing::hashing::LigandBindingResPlacer::revert_last_added_contact(class std::shared_ptr<class protocols::sewing::data_storage::SmartAssembly>) –> void

set_best_geometry_score(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, : float) None

C++: protocols::sewing::hashing::LigandBindingResPlacer::set_best_geometry_score(double) –> void

set_geometry_score_weight(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, : float) None

C++: protocols::sewing::hashing::LigandBindingResPlacer::set_geometry_score_weight(double) –> void

set_ligand(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandBindingResPlacer, lig: protocols::sewing::data_storage::LigandResidue) None

C++: protocols::sewing::hashing::LigandBindingResPlacer::set_ligand(class std::shared_ptr<class protocols::sewing::data_storage::LigandResidue>) –> void

class pyrosetta.rosetta.protocols.sewing.hashing.LigandCoordInfo

Bases: pybind11_builtins.pybind11_object

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.LigandCoordInfo, : pyrosetta.rosetta.protocols.sewing.hashing.LigandCoordInfo) pyrosetta.rosetta.protocols.sewing.hashing.LigandCoordInfo

C++: protocols::sewing::hashing::LigandCoordInfo::operator=(const struct protocols::sewing::hashing::LigandCoordInfo &) –> struct protocols::sewing::hashing::LigandCoordInfo &

property chis
property coord_atom_index
property coord_res_name
property ligand_atom_index
property local_coords
class pyrosetta.rosetta.protocols.sewing.hashing.ModelFileReader

Bases: pybind11_builtins.pybind11_object

a reader of SEWING model files

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.ModelFileReader, : pyrosetta.rosetta.protocols.sewing.hashing.ModelFileReader) pyrosetta.rosetta.protocols.sewing.hashing.ModelFileReader

C++: protocols::sewing::hashing::ModelFileReader::operator=(const class protocols::sewing::hashing::ModelFileReader &) –> class protocols::sewing::hashing::ModelFileReader &

clone(self: pyrosetta.rosetta.protocols.sewing.hashing.ModelFileReader) pyrosetta.rosetta.protocols.sewing.hashing.ModelFileReader

C++: protocols::sewing::hashing::ModelFileReader::clone() const –> class std::shared_ptr<class protocols::sewing::hashing::ModelFileReader>

static read_model_file(filename: str) pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

C++: protocols::sewing::hashing::ModelFileReader::read_model_file(std::string) –> class std::shared_ptr<class protocols::sewing::hashing::SegmentVector>

class pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

Bases: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t

append(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: protocols::sewing::data_storage::SmartSegment) None

adds an element to the end

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector, : pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector) pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector

C++: protocols::sewing::hashing::SegmentVector::operator=(const class protocols::sewing::hashing::SegmentVector &) –> class protocols::sewing::hashing::SegmentVector &

back(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) protocols::sewing::data_storage::SmartSegment

access the last element

capacity(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) int

returns the number of elements that can be held in currently allocated storage

clear(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) None

clears the contents

count(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: protocols::sewing::data_storage::SmartSegment) int

counts the elements that are equal to value

erase(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: int) None

erases element at index

extend(othervec)
front(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) protocols::sewing::data_storage::SmartSegment

access the first element

get_version(self: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector) int

C++: protocols::sewing::hashing::SegmentVector::get_version() const –> unsigned long

l(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) int

lower index

max_size(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) int

returns the maximum possible number of elements

pop(*args, **kwargs)

Overloaded function.

  1. pop(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) -> protocols::sewing::data_storage::SmartSegment

remove and return last item

  1. pop(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: int) -> protocols::sewing::data_storage::SmartSegment

remove and return item at index

remove(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: protocols::sewing::data_storage::SmartSegment) None

Remove the first item from the list whose value is x. It is an error if there is no such item.

reserve(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: int) None

reserves storage

resize(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t, arg0: int) None

changes the number of elements stored

set_version(self: pyrosetta.rosetta.protocols.sewing.hashing.SegmentVector, ver: int) None

C++: protocols::sewing::hashing::SegmentVector::set_version(unsigned long) –> void

shrink_to_fit(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) None

reduces memory usage by freeing unused memory

u(self: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t) int

upper index

class pyrosetta.rosetta.protocols.sewing.hashing.coord_equal_to

Bases: pyrosetta.rosetta.std.binary_function_utility_fixedsizearray1_int_3_utility_fixedsizearray1_int_3_bool_t

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.coord_equal_to, : pyrosetta.rosetta.protocols.sewing.hashing.coord_equal_to) pyrosetta.rosetta.protocols.sewing.hashing.coord_equal_to

C++: protocols::sewing::hashing::coord_equal_to::operator=(const struct protocols::sewing::hashing::coord_equal_to &) –> struct protocols::sewing::hashing::coord_equal_to &

class pyrosetta.rosetta.protocols.sewing.hashing.coord_hash

Bases: pyrosetta.rosetta.std.unary_function_utility_fixedsizearray1_int_3_unsigned_long_t

assign(self: pyrosetta.rosetta.protocols.sewing.hashing.coord_hash, : pyrosetta.rosetta.protocols.sewing.hashing.coord_hash) pyrosetta.rosetta.protocols.sewing.hashing.coord_hash

C++: protocols::sewing::hashing::coord_hash::operator=(const struct protocols::sewing::hashing::coord_hash &) –> struct protocols::sewing::hashing::coord_hash &