Rosetta  2020.37
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Private Attributes | List of all members
core::chemical::PoseResidueTypeSet Class Reference

A ResidueTypeSet which can be cached in the Pose. More...

#include <PoseResidueTypeSet.hh>

Inheritance diagram for core::chemical::PoseResidueTypeSet:
Inheritance graph
[legend]

Public Member Functions

 PoseResidueTypeSet (TypeSetMode mode=INVALID_t)
 
 PoseResidueTypeSet (ResidueTypeSetCOP deflt_rts)
 
 PoseResidueTypeSet (PoseResidueTypeSet const &src)
 
virtual PoseResidueTypeSetOP clone () const
 
virtual ~PoseResidueTypeSet ()
 
void default_rts (core::chemical::ResidueTypeSetCOP setting)
 Set the default fall-back ResidueTypeSet. More...
 
core::chemical::ResidueTypeSetCOP default_rts () const
 What is the default fall-back ResidueTypesSet. More...
 
ResidueTypeCOP get_d_equivalent (ResidueTypeCOP l_rsd) const override
 Given a D-residue, get its L-equivalent. More...
 
ResidueTypeCOP get_l_equivalent (ResidueTypeCOP d_rsd) const override
 Given an L-residue, get its D-equivalent. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueTypeCOP get_mirrored_type (ResidueTypeCOP original_rsd) const override
 Given a residue, get its mirror-image type. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
bool generates_patched_residue_type_with_name3 (std::string const &base_residue_name, std::string const &name3) const override
 Check if a base type (like "SER") generates any types with another name3 (like "SEP") More...
 
bool generates_patched_residue_type_with_interchangeability_group (std::string const &base_residue_name, std::string const &interchangeability_group) const override
 Check if a base type (like "CYS") generates any types with a new interchangeability group (like "SCY" (via cys_acetylated)) More...
 
ResidueTypeCOPs base_residue_types () const override
 the residues with no patches applied More...
 
ResidueTypeCOPs unpatchable_residue_types () const override
 the residues with no patches applied More...
 
utility::vector1< PatchCOPpatches () const override
 the patches More...
 
utility::vector1< MetapatchCOPmetapatches () const override
 the metapatches More...
 
std::map< std::string,
utility::vector1< PatchCOP >
> const & 
patch_map () const override
 the patches, index by name. More...
 
std::map< std::string,
MetapatchCOP > const & 
metapatch_map () const override
 the metapatches, index by name. More...
 
bool has_metapatch (std::string const &name) const override
 Do we have this metapatch? More...
 
MetapatchCOP metapatch (std::string const &name) const override
 
ResidueTypeCOPs get_all_types_with_variants_aa (AA aa, utility::vector1< std::string > const &variants) const override
 Gets all types with the given aa type and variants. More...
 
ResidueTypeCOPs get_all_types_with_variants_aa (AA aa, utility::vector1< std::string > const &variants, utility::vector1< VariantType > const &exceptions) const override
 Gets all types with the given aa type and variants, making exceptions for some variants. More...
 
void add_base_residue_type (MutableResidueTypeOP new_type) override
 adds a new base residue type to the set, one that isn't patched, but can be. (Needs a modifiable type so that it can call prep_restype() on it.) Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. More...
 
void add_base_residue_type (std::string const &filename) override
 adds a new residue type to the set, one that can be patched Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. More...
 
void read_files_for_base_residue_types (utility::vector1< std::string > const &filenames) override
 adds new residue types, ones that can be patched Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. More...
 
void add_unpatchable_residue_type (MutableResidueTypeOP new_type) override
 adds a new residue type to the set, one that CANNOT be generated from a base_residue_type and patches, and shouldn't have patches applied (Needs a modifiable type so that it can call prep_restype() on it.) Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. More...
 
void add_unpatchable_residue_type (std::string const &filename) override
 adds a new residue type to the set, one that CANNOT be generated from a base_residue_type and patches, and shouldn't have patches applied Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. More...
 
void read_files_for_unpatchable_residue_types (utility::vector1< std::string > const &filenames) override
 adds new residue types, ones that CANNOT be generated from a base_residue_type and patches, and shouldn't have patches applied Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. More...
 
void remove_base_residue_type (std::string const &name) override
 delete an base residue type from the set (Use with care) Currently will not remove any patched types Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. In any case, this is not a thread-safe function as it will invariably lead to race conditions if the RTS is shared between two threads. This method is only to be used on PoseResidueTypeSet objects (the GlobalResidueTypeSet class will exit if you call it), and these objects must not be shared between two threads. More...
 
void remove_unpatchable_residue_type (std::string const &name) override
 delete an unpatchable residue type from the set (Use with care) Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. In any case, this is not a thread-safe function as it will invariably lead to race conditions if the RTS is shared between two threads. This method is only to be used on PoseResidueTypeSet objects (the GlobalResidueTypeSet class will exit if you call it), and these objects must not be shared between two threads. More...
 
void add_patches (utility::vector1< std::string > const &patch_filenames, utility::vector1< std::string > const &metapatch_filenames) override
 
void set_merge_behavior_manager (MergeBehaviorManagerCOP mbm) override
 
AtomTypeSetCOP atom_type_set () const
 
ElementSetCOP element_set () const
 
MMAtomTypeSetCOP mm_atom_type_set () const
 
orbitals::OrbitalTypeSetCOP orbital_type_set () const
 
void atom_type_set (AtomTypeSetCOP atom_types)
 
void element_set (ElementSetCOP elements)
 
void mm_atom_type_set (MMAtomTypeSetCOP mm_atom_types)
 
void orbital_type_set (orbitals::OrbitalTypeSetCOP orbital_types)
 
- Public Member Functions inherited from core::chemical::ResidueTypeSet
 ResidueTypeSet (TypeSetMode mode=INVALID_t)
 default c-tor More...
 
 ~ResidueTypeSet ()
 
ResidueTypeSetCOP get_self_ptr () const
 
ResidueTypeSetCAP get_self_weak_ptr () const
 
AtomTypeSetCOP atom_type_set () const
 
ElementSetCOP element_set () const
 
MMAtomTypeSetCOP mm_atom_type_set () const
 
orbitals::OrbitalTypeSetCOP orbital_type_set () const
 
TypeSetMode mode () const
 The type of the ResidueTypeSet. More...
 
virtual ResidueType const & name_map (std::string const &name) const
 query ResidueType by its unique residue id. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
virtual ResidueTypeCOP name_mapOP (std::string const &name) const
 Get ResidueType by exact name, returning COP. Will return null pointer for no matches. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
virtual bool has_name (std::string const &name) const
 query if a ResidueType of the unique residue id (name) is present. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
bool has_name3 (std::string const &name3) const
 query if any ResidueTypes in the set have a "name3" that matches the input name3 Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
bool has_interchangeability_group (std::string const &name) const
 Does this ResidueTypeSet have ResidueTypes with the given interchangeability group? Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueTypeCOP get_representative_type_aa (AA aa, utility::vector1< std::string > const &variants) const
 Get the base ResidueType with the given aa type and variants. More...
 
ResidueTypeCOP get_representative_type_aa (AA aa) const
 
ResidueTypeCOP get_representative_type_name1 (char name1, utility::vector1< std::string > const &variants) const
 Get the base ResidueType with the given name1 and variants. More...
 
ResidueTypeCOP get_representative_type_name1 (char name1) const
 
ResidueTypeCOP get_representative_type_name3 (std::string const &name3, utility::vector1< std::string > const &variants) const
 Get the base ResidueType with the given name3 and variants. More...
 
ResidueTypeCOP get_representative_type_name3 (std::string const &name3) const
 
ResidueTypeCOP get_representative_type_base_name (std::string const &base_name) const
 
ResidueTypeCOPs get_base_types_aa (AA aa) const
 Gets all non-patched types with the given aa type Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueTypeCOPs get_base_types_name1 (char name1) const
 Get all non-patched ResidueTypes with the given name1 Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueTypeCOPs get_base_types_name3 (std::string const &name3) const
 Get all non-patched ResidueTypes with the given name3 Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueTypeCOPs get_all_types_with_variants_name1 (char name1, utility::vector1< std::string > const &variants) const
 Get all non-patched ResidueTypes with the given name1 Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueTypeCOPs get_all_types_with_variants_name3 (std::string const &name3, utility::vector1< std::string > const &variants) const
 Get all non-patched ResidueTypes with the given name3 Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueType const & get_residue_type_with_variant_added (ResidueType const &init_rsd, VariantType const new_type) const
 Query a variant ResidueType by its base ResidueType and VariantType Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
ResidueType const & get_residue_type_with_variant_added (ResidueType const &init_rsd, std::string const &new_type) const
 
ResidueType const & get_residue_type_with_custom_variant_added (ResidueType const &init_rsd, std::string const &new_type) const
 
ResidueType const & get_residue_type_with_variant_removed (ResidueType const &init_rsd, VariantType const old_type) const
 return the residuetype we get from variant rsd type after removing the desired variant type Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache. More...
 
MergeBehaviorManager const & merge_behavior_manager () const
 accessor for merge behavior manager More...
 
ResidueTypeCOPs get_all_types_with_variants_by_basetype (ResidueTypeCOP base_type, utility::vector1< VariantType > const &variants, utility::vector1< std::string > const &variant_strings, utility::vector1< VariantType > const &exceptions, bool const no_metapatches) const
 Given a base residue type, desired variants, and undesired variants, retrieve a list of cached ResidueTypeCOPs. If not cached, generate the data and cache them. More...
 

Protected Member Functions

void add_patch (PatchCOP p) override
 Add a patch object to the RTS. More...
 
void add_metapatch (MetapatchCOP p) override
 Add a metapatch object to the RTS. More...
 
ResidueTypeCOP generate_residue_type_write_locked (std::string const &name_in) const override
 Generate the ResidueType from either/both of the local RTS and the default RTS. More...
 
bool lazy_load_base_type_already_write_locked (std::string const &rsd_base_name) const override
 Attempt to lazily load the given residue type from data. More...
 
- Protected Member Functions inherited from core::chemical::ResidueTypeSet
void atom_type_set (AtomTypeSetCOP atom_types)
 
void element_set (ElementSetCOP elements)
 
void mm_atom_type_set (MMAtomTypeSetCOP mm_atom_types)
 
void orbital_type_set (orbitals::OrbitalTypeSetCOP orbital_types)
 
void prep_restype (MutableResidueTypeOP new_type) const
 Centralize the steps for preparing the ResidueType for addition to the RTS (e.g. if there's any additional modifications that need to get done.) More...
 
virtual void force_add_base_residue_type_already_write_locked (MutableResidueTypeOP new_type) const
 Force the addition of a new residue type despite a const context. More...
 
bool update_base_residue_types_if_replaced (ResidueTypeCOP rsd_type, ResidueTypeCOP rsd_type_new)
 helper function used during replacing residue types after, e.g., orbitals. Does not lock the RTSC, but does modify the RTS and should not be used outside of construction in a multi-threaded context More...
 
void mode (TypeSetMode setting)
 
ResidueTypeSetCacheOP cache_object () const
 The alterable cache object. More...
 
virtual ResidueTypeCOP generate_residue_type (std::string const &rsd_name) const
 Template method invoked by the base class to be overridden by the derived class when a not-yet-generated ResidueType is requested by name. The function returns the COP of the ResidueType if it can be generated, and a nullptr if it cannot. More...
 
MutableResidueTypeCOP apply_patch (ResidueTypeCOP const &rsd_base_ptr, std::string const &patch_name, std::map< std::string, utility::vector1< PatchCOP > > const &patch_mapping, std::map< std::string, MetapatchCOP > const &metapach_mapping) const
 Static method which will apply a given patch to a given ResidueType If the patch cannot be applies, it will return nullptr. More...
 
virtual ResidueTypeCOP name_mapOP_write_locked (std::string const &name) const
 Template method to return a residue type with the given name, updating the ResidueTypeSetCache as needed – meant to be overridden by the derived ResidueTypeSet. Note that this method must only be called by a function that has obtained a write lock or a function that itself requires a write lock to call it. The derived class's version of this method must not attempt to call any function that would itself try to obtain a read- or write lock on the ResidueTypeSetCache. More...
 
virtual bool has_name_write_locked (std::string const &name) const
 Template method to return whether a residue type with a given name is creatable or has already been created; meant to be overridden by the derived ResidueTypeSet. Note that this should only be invoked after a write lock has been obtained on the ResidueTypeSetCache (e.g. inside functions within the generate_residue_type call chain); and that the derived class's version of this function must assume a write lock has already been obtained when it is invoked. Therefore, it must not attempt to call any function that would itself try and obtain a read or write lock. More...
 
void figure_out_last_patch_from_name (std::string const &rsd_name, std::string &rsd_name_base, std::string &patch_name) const
 
std::map< ResidueTypeCOP,
ResidueTypeCOP > & 
l_to_d_mapping ()
 A list of L-chirality base types with an equivalent D-chirality base type. More...
 
std::map< ResidueTypeCOP,
ResidueTypeCOP > & 
d_to_l_mapping ()
 A list of D-chirality base types with an equivalent L-chirality base type. More...
 
 ResidueTypeSet (ResidueTypeSet const &)
 
ResidueTypeSetoperator= (ResidueTypeSet const &)=delete
 

Private Attributes

core::chemical::ResidueTypeSetCOP default_rts_
 
std::map< std::string,
utility::vector1< PatchCOP > > 
all_patch_map_
 patches indexed by name Includes both the patches from this map and the default_rts_ patches. More...
 
std::map< std::string,
MetapatchCOP
all_metapatch_map_
 

Detailed Description

A ResidueTypeSet which can be cached in the Pose.

Constructor & Destructor Documentation

core::chemical::PoseResidueTypeSet::PoseResidueTypeSet ( TypeSetMode  mode = INVALID_t)
core::chemical::PoseResidueTypeSet::PoseResidueTypeSet ( ResidueTypeSetCOP  deflt_rts)

References default_rts().

core::chemical::PoseResidueTypeSet::PoseResidueTypeSet ( PoseResidueTypeSet const &  src)
default
core::chemical::PoseResidueTypeSet::~PoseResidueTypeSet ( )
virtualdefault

Member Function Documentation

void core::chemical::PoseResidueTypeSet::add_base_residue_type ( MutableResidueTypeOP  new_type)
overridevirtual

adds a new base residue type to the set, one that isn't patched, but can be. (Needs a modifiable type so that it can call prep_restype() on it.) Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::add_base_residue_type().

void core::chemical::PoseResidueTypeSet::add_base_residue_type ( std::string const &  filename)
overridevirtual

adds a new residue type to the set, one that can be patched Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::add_base_residue_type().

void core::chemical::PoseResidueTypeSet::add_metapatch ( MetapatchCOP  p)
overrideprotectedvirtual

Add a metapatch object to the RTS.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::add_metapatch(), and all_metapatch_map_.

void core::chemical::PoseResidueTypeSet::add_patch ( PatchCOP  p)
overrideprotectedvirtual

Add a patch object to the RTS.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::add_patch(), and all_patch_map_.

void core::chemical::PoseResidueTypeSet::add_patches ( utility::vector1< std::string > const &  patch_filenames,
utility::vector1< std::string > const &  metapatch_filenames 
)
overridevirtual
void core::chemical::PoseResidueTypeSet::add_unpatchable_residue_type ( MutableResidueTypeOP  new_type)
overridevirtual

adds a new residue type to the set, one that CANNOT be generated from a base_residue_type and patches, and shouldn't have patches applied (Needs a modifiable type so that it can call prep_restype() on it.) Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::add_unpatchable_residue_type().

void core::chemical::PoseResidueTypeSet::add_unpatchable_residue_type ( std::string const &  filename)
overridevirtual

adds a new residue type to the set, one that CANNOT be generated from a base_residue_type and patches, and shouldn't have patches applied Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::add_unpatchable_residue_type().

AtomTypeSetCOP core::chemical::PoseResidueTypeSet::atom_type_set ( ) const
inline
void core::chemical::PoseResidueTypeSet::atom_type_set ( AtomTypeSetCOP  atom_types)
ResidueTypeCOPs core::chemical::PoseResidueTypeSet::base_residue_types ( ) const
overridevirtual

the residues with no patches applied

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::base_residue_types(), and default_rts_.

PoseResidueTypeSetOP core::chemical::PoseResidueTypeSet::clone ( ) const
virtual
void core::chemical::PoseResidueTypeSet::default_rts ( core::chemical::ResidueTypeSetCOP  setting)
core::chemical::ResidueTypeSetCOP core::chemical::PoseResidueTypeSet::default_rts ( ) const

What is the default fall-back ResidueTypesSet.

References default_rts_.

Referenced by PoseResidueTypeSet().

ElementSetCOP core::chemical::PoseResidueTypeSet::element_set ( ) const
inline
void core::chemical::PoseResidueTypeSet::element_set ( ElementSetCOP  elements)
ResidueTypeCOP core::chemical::PoseResidueTypeSet::generate_residue_type_write_locked ( std::string const &  name_in) const
overrideprotectedvirtual
bool core::chemical::PoseResidueTypeSet::generates_patched_residue_type_with_interchangeability_group ( std::string const &  base_residue_name,
std::string const &  interchangeability_group 
) const
overridevirtual

Check if a base type (like "CYS") generates any types with a new interchangeability group (like "SCY" (via cys_acetylated))

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_, and core::chemical::ResidueTypeSet::generates_patched_residue_type_with_interchangeability_group().

bool core::chemical::PoseResidueTypeSet::generates_patched_residue_type_with_name3 ( std::string const &  base_residue_name,
std::string const &  name3 
) const
overridevirtual

Check if a base type (like "SER") generates any types with another name3 (like "SEP")

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_, and core::chemical::ResidueTypeSet::generates_patched_residue_type_with_name3().

ResidueTypeCOPs core::chemical::PoseResidueTypeSet::get_all_types_with_variants_aa ( AA  aa,
utility::vector1< std::string > const &  variants 
) const
overridevirtual

Gets all types with the given aa type and variants.

The number of variants must match exactly. Variants can be custom variants. (It's assumed that the passed VariantTypeList contains no duplicates.)

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_, and core::chemical::ResidueTypeSet::get_all_types_with_variants_aa().

ResidueTypeCOPs core::chemical::PoseResidueTypeSet::get_all_types_with_variants_aa ( AA  aa,
utility::vector1< std::string > const &  variants,
utility::vector1< VariantType > const &  exceptions 
) const
overridevirtual

Gets all types with the given aa type and variants, making exceptions for some variants.

The number of variants must match exactly. Variants can be custom variants, but exceptions must be standard types, listed in VariantType.hh. (It's assumed that the passed VariantTypeList contains no duplicates.)

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_, and core::chemical::ResidueTypeSet::get_all_types_with_variants_aa().

ResidueTypeCOP core::chemical::PoseResidueTypeSet::get_d_equivalent ( ResidueTypeCOP  l_rsd) const
overridevirtual

Given a D-residue, get its L-equivalent.

Given an L-residue, get its D-equivalent.

Returns NULL if there is no equivalent, true otherwise. Throws an error if this is not a D-residue. Preserves variant types. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache.

Note
Works for L-amino acids and L-peptoids (peptoids with chiral "L" sidechains").
Author
Vikram K. Mulligan (vmull.nosp@m.ig@u.nosp@m.w.edu).

Returns NULL if there is no equivalent, true otherwise. Throws an error if this is not a D-residue. Preserves variant types.

Note
Works for L-amino acids and L-peptoids (peptoids with chiral "L" sidechains").
Author
Vikram K. Mulligan (vmull.nosp@m.ig@u.nosp@m.w.edu).

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_.

ResidueTypeCOP core::chemical::PoseResidueTypeSet::get_l_equivalent ( ResidueTypeCOP  d_rsd) const
overridevirtual

Given an L-residue, get its D-equivalent. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache.

Given an D-residue, get its L-equivalent.

Returns NULL if there is no equivalent, true otherwise. Throws an error if this is not an L-residue. Preserves variant types.

Note
Works for D-amino acids and D-peptoids (peptoids with chiral "D" sidechains").
Author
Vikram K. Mulligan (vmull.nosp@m.ig@u.nosp@m.w.edu).

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_.

ResidueTypeCOP core::chemical::PoseResidueTypeSet::get_mirrored_type ( ResidueTypeCOP  original_rsd) const
overridevirtual

Given a residue, get its mirror-image type. Note for derived classes: this method will obtain a read lock, and possibly a write lock on the ResidueTypeSetCache.

Given a residue, get its mirror-image type.

Returns the same residue if this is an ACHIRAL type (e.g. gly), the D-equivalent for an L-residue, the L-equivalent of a D-residue, or NULL if this is an L-residue with no D-equivalent (or a D- with no L-equivalent). Preserves variant types.

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_.

bool core::chemical::PoseResidueTypeSet::has_metapatch ( std::string const &  name) const
overridevirtual

Do we have this metapatch?

Reimplemented from core::chemical::ResidueTypeSet.

References all_metapatch_map_.

bool core::chemical::PoseResidueTypeSet::lazy_load_base_type_already_write_locked ( std::string const &  rsd_base_name) const
overrideprotectedvirtual

Attempt to lazily load the given residue type from data.

Implements core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::cache_object().

MetapatchCOP core::chemical::PoseResidueTypeSet::metapatch ( std::string const &  name) const
overridevirtual

Reimplemented from core::chemical::ResidueTypeSet.

References all_metapatch_map_.

std::map< std::string, MetapatchCOP > const& core::chemical::PoseResidueTypeSet::metapatch_map ( ) const
inlineoverridevirtual

the metapatches, index by name.

Reimplemented from core::chemical::ResidueTypeSet.

References all_metapatch_map_.

Referenced by generate_residue_type_write_locked().

utility::vector1< MetapatchCOP > core::chemical::PoseResidueTypeSet::metapatches ( ) const
overridevirtual
MMAtomTypeSetCOP core::chemical::PoseResidueTypeSet::mm_atom_type_set ( ) const
inline
void core::chemical::PoseResidueTypeSet::mm_atom_type_set ( MMAtomTypeSetCOP  mm_atom_types)
orbitals::OrbitalTypeSetCOP core::chemical::PoseResidueTypeSet::orbital_type_set ( ) const
inline
void core::chemical::PoseResidueTypeSet::orbital_type_set ( orbitals::OrbitalTypeSetCOP  orbital_types)
std::map< std::string, utility::vector1< PatchCOP > > const& core::chemical::PoseResidueTypeSet::patch_map ( ) const
inlineoverridevirtual

the patches, index by name.

Reimplemented from core::chemical::ResidueTypeSet.

References all_patch_map_.

Referenced by generate_residue_type_write_locked().

utility::vector1< PatchCOP > core::chemical::PoseResidueTypeSet::patches ( ) const
overridevirtual
void core::chemical::PoseResidueTypeSet::read_files_for_base_residue_types ( utility::vector1< std::string > const &  filenames)
overridevirtual

adds new residue types, ones that can be patched Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::read_files_for_base_residue_types().

void core::chemical::PoseResidueTypeSet::read_files_for_unpatchable_residue_types ( utility::vector1< std::string > const &  filenames)
overridevirtual

adds new residue types, ones that CANNOT be generated from a base_residue_type and patches, and shouldn't have patches applied Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::read_files_for_unpatchable_residue_types().

void core::chemical::PoseResidueTypeSet::remove_base_residue_type ( std::string const &  name)
overridevirtual

delete an base residue type from the set (Use with care) Currently will not remove any patched types Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. In any case, this is not a thread-safe function as it will invariably lead to race conditions if the RTS is shared between two threads. This method is only to be used on PoseResidueTypeSet objects (the GlobalResidueTypeSet class will exit if you call it), and these objects must not be shared between two threads.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::remove_base_residue_type().

void core::chemical::PoseResidueTypeSet::remove_unpatchable_residue_type ( std::string const &  name)
overridevirtual

delete an unpatchable residue type from the set (Use with care) Note: creates write lock on RTSC and must not be invoked in the generate_residue_type_write_locked call chain. In any case, this is not a thread-safe function as it will invariably lead to race conditions if the RTS is shared between two threads. This method is only to be used on PoseResidueTypeSet objects (the GlobalResidueTypeSet class will exit if you call it), and these objects must not be shared between two threads.

Reimplemented from core::chemical::ResidueTypeSet.

References core::chemical::ResidueTypeSet::remove_unpatchable_residue_type().

void core::chemical::PoseResidueTypeSet::set_merge_behavior_manager ( MergeBehaviorManagerCOP  mbm)
overridevirtual
ResidueTypeCOPs core::chemical::PoseResidueTypeSet::unpatchable_residue_types ( ) const
overridevirtual

the residues with no patches applied

Reimplemented from core::chemical::ResidueTypeSet.

References default_rts_, and core::chemical::ResidueTypeSet::unpatchable_residue_types().

Member Data Documentation

std::map< std::string, MetapatchCOP > core::chemical::PoseResidueTypeSet::all_metapatch_map_
private
std::map< std::string, utility::vector1< PatchCOP > > core::chemical::PoseResidueTypeSet::all_patch_map_
private

patches indexed by name Includes both the patches from this map and the default_rts_ patches.

Referenced by add_patch(), default_rts(), and patch_map().

core::chemical::ResidueTypeSetCOP core::chemical::PoseResidueTypeSet::default_rts_
private

The documentation for this class was generated from the following files: