hashing¶

Bindings for protocols::sewing::hashing namespace

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

Bases: 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: 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.

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

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_std_allocator_std_pair_const_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.

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>

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.

show(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentFileGeneratorMover) -> None
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.

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

Bases: 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_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_std_allocator_std_pair_const_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.

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

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.

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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> > > > &

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.AlignmentGenerator, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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.

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>

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

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>

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.

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

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.

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

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_std_allocator_std_pair_const_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.

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

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.

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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> > > > &

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.BasisMapGenerator, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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.

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>

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.

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

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

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

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

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

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.

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

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.

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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> > > > &

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.EdgeMapGenerator, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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.

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>

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.

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

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

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_object

property atomno¶

property basis_resnum¶

property basis_segment_id¶

property resnum¶

property segment_id¶

class pyrosetta.rosetta.protocols.sewing.hashing.Hasher¶

Bases: 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_std_allocator_std_pair_const_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.

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

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.

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher) -> pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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> > > > &

pdb_segments(self: pyrosetta.rosetta.protocols.sewing.hashing.Hasher, : pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_protocols_sewing_data_storage_SmartSegment_t_std_allocator_std_pair_const_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.

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>

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_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_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_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_std_less_std_pair_unsigned_long_unsigned_long_t_std_allocator_std_pair_const_std_pair_unsigned_long_unsigned_long_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_std_less_std_pair_unsigned_long_unsigned_long_t_std_allocator_std_pair_const_std_pair_unsigned_long_unsigned_long_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_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_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: 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.

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

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: pybind11_object

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: pybind11_object

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 &