ligand_evolution¶

Bindings for protocols::ligand_evolution namespace

class pyrosetta.rosetta.protocols.ligand_evolution.Crossover¶

Bases: OffspringFactory

Takes two individuals and produces a set amount of offspring using a crossover.

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.Crossover, parents: pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual, n_offspring: int) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Selects randomly two parents to create offspring until n_offspring is available

One random parent donates the reaction and both donate minimum one reagent. If they come from different reactions, the alien reagent is mapped to the most similar
counterpart.

C++: protocols::ligand_evolution::Crossover::apply(const class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &, unsigned long) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.Crossover) → str¶

Returns the name of this factory

C++: protocols::ligand_evolution::Crossover::name() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.ElitistSelector¶

Bases: Selector

Selects only the best scored individuals

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.ElitistSelector, population: pyrosetta.rosetta.protocols.ligand_evolution.Population, size: int, remove: bool) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Returns the indices of the size fittest individuals in population.

C++: protocols::ligand_evolution::ElitistSelector::apply(class protocols::ligand_evolution::Population &, unsigned long, bool) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.ElitistSelector) → str¶

Return the name of this selector

C++: protocols::ligand_evolution::ElitistSelector::name() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.EvolutionManager¶

Bases: pybind11_object

The EvolutionManager combines all required resources for the evolutionary ligand optimization and handles them as needed.

_pybind11_conduit_v1_()¶

init(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionManager) → None¶: C++: protocols::ligand_evolution::EvolutionManager::init() –> void

run(*args, **kwargs)¶

Overloaded function.

run(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionManager) -> None
run(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionManager, mpi_size: int) -> None

Main function that handles evolutionary optimization

C++: protocols::ligand_evolution::EvolutionManager::run(int) –> void

scores_to_str(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionManager) → str¶

Prints scores of all individuals

C++: protocols::ligand_evolution::EvolutionManager::scores_to_str() const –> std::string

class pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions¶

Bases: pybind11_object

Within EvolutionOptions class combines all options and settings are collected, defaults saved and sanity checks performed before running

_pybind11_conduit_v1_()¶

get_external_scoring(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → int¶

Returns number of external scoring runs or zero if evolutionary optimization should be used

C++: protocols::ligand_evolution::EvolutionOptions::get_external_scoring() const –> unsigned long

get_factory_names(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → pyrosetta.rosetta.utility.vector1_std_string¶

Returns all factory names

C++: protocols::ligand_evolution::EvolutionOptions::get_factory_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_factory_parameter(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions, name: str, parameter: str) → float¶

Returns a required parameter for one factory

C++: protocols::ligand_evolution::EvolutionOptions::get_factory_parameter(const std::string &, const std::string &) const –> double

get_factory_type(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions, name: str) → str¶

Returns the type of one factory

C++: protocols::ligand_evolution::EvolutionOptions::get_factory_type(const std::string &) const –> const std::string &

get_ligand_chain(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the name of the ligand chain used by all movers

C++: protocols::ligand_evolution::EvolutionOptions::get_ligand_chain() const –> const std::string &

get_main_scfx(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the name of the score function used for the main scores within the scorer

C++: protocols::ligand_evolution::EvolutionOptions::get_main_scfx() const –> const std::string &

get_main_selector(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the name of the main selector

C++: protocols::ligand_evolution::EvolutionOptions::get_main_selector() const –> const std::string &

get_main_term(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the name of the score term to optimize for

C++: protocols::ligand_evolution::EvolutionOptions::get_main_term() const –> const std::string &

get_max_generations(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → int¶

Returns maximum number of generations

C++: protocols::ligand_evolution::EvolutionOptions::get_max_generations() const –> unsigned long

get_n_scoring_runs(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → int¶

Returns the number of scoring runs

C++: protocols::ligand_evolution::EvolutionOptions::get_n_scoring_runs() const –> unsigned long

get_path_score_memory(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the path to a score memory file

C++: protocols::ligand_evolution::EvolutionOptions::get_path_score_memory() const –> const std::string &

get_path_to_external_smiles(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the path to a list of smiles which will all be scored

C++: protocols::ligand_evolution::EvolutionOptions::get_path_to_external_smiles() const –> const std::string &

get_path_to_reactions(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the path to a list of reactions in SMARTS, defining combinatorial rules

C++: protocols::ligand_evolution::EvolutionOptions::get_path_to_reactions() const –> const std::string &

get_path_to_reagents(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the path to a list of reagents in SMILES defining the fragments for combination

C++: protocols::ligand_evolution::EvolutionOptions::get_path_to_reagents() const –> const std::string &

get_pop_init_options(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → pyrosetta.rosetta.std.map_std_string_std_map_std_string_unsigned_long_std_less_std_string_std_allocator_std_pair_const_std_string_unsigned_long_t_std_allocator_std_pair_const_std_string_std_map_std_string_unsigned_long_std_less_std_string_std_allocator_std_pair_const_std_string_unsigned_long_t¶

Returns a map of all used pop initialization procedures

C++: protocols::ligand_evolution::EvolutionOptions::get_pop_init_options() const –> const class std::map<std::string, class std::map<std::string, unsigned long, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, unsigned long> > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::map<std::string, unsigned long, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, unsigned long> > > > > > &

get_population_supported_size(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → int¶

Returns how many individuals are supported per generation, essentially defining how many can survive

C++: protocols::ligand_evolution::EvolutionOptions::get_population_supported_size() const –> unsigned long

get_pose_dir_path(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶

Returns the path to directory where all poses will be saved

C++: protocols::ligand_evolution::EvolutionOptions::get_pose_dir_path() const –> const std::string &

get_pose_from_stream(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::ligand_evolution::EvolutionOptions::get_pose_from_stream() –> class std::shared_ptr<class core::pose::Pose>

get_protocol_path(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → str¶: C++: protocols::ligand_evolution::EvolutionOptions::get_protocol_path() const –> const std::string &

get_selector_factory_links(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → pyrosetta.rosetta.utility.vector1_std_pair_std_string_std_string_t¶

Return the list of factory and selector links. The order defines the order of appliance

C++: protocols::ligand_evolution::EvolutionOptions::get_selector_factory_links() const –> const class utility::vector1<struct std::pair<std::string, std::string >, class std::allocator<struct std::pair<std::string, std::string > > > &

get_selector_names(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → pyrosetta.rosetta.utility.vector1_std_string¶

Returns all selector names

C++: protocols::ligand_evolution::EvolutionOptions::get_selector_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_selector_parameter(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions, name: str, parameter: str) → float¶

Returns a required parameter for one selector

C++: protocols::ligand_evolution::EvolutionOptions::get_selector_parameter(const std::string &, const std::string &) const –> double

get_selector_type(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions, name: str) → str¶

Returns the type of one selector

C++: protocols::ligand_evolution::EvolutionOptions::get_selector_type(const std::string &) const –> const std::string &

get_similarity_penalty(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → float¶

Return the similarity penalty for similar ligands in one generation

C++: protocols::ligand_evolution::EvolutionOptions::get_similarity_penalty() const –> double

get_similarity_penalty_threshold(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → float¶

Return the identity penalty threshold after which the penalty is applied to the lower scoring molecule

C++: protocols::ligand_evolution::EvolutionOptions::get_similarity_penalty_threshold() const –> double

get_start_xyz(self: pyrosetta.rosetta.protocols.ligand_evolution.EvolutionOptions) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: protocols::ligand_evolution::EvolutionOptions::get_start_xyz() const –> class numeric::xyzVector<double>

class pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary¶

Bases: pybind11_object

The %FragmentLibrary implements a combinatorial library for reaction and reagent data. Its main task is to hold chemical information and provide new ligands.

_pybind11_conduit_v1_()¶

calculate_fingerprint(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, id: pyrosetta.rosetta.utility.vector1_unsigned_long) → RDKit::SparseIntVect<unsigned int>¶

Calculates a RDKit Morgan fingerprint for a given ligand. Fingerprints are saved and can be retrieved quickly.

C++: protocols::ligand_evolution::FragmentLibrary::calculate_fingerprint(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> class std::shared_ptr<class RDKit::SparseIntVect<unsigned int> >

create_ligand_pose(*args, **kwargs)¶

Overloaded function.

create_ligand_pose(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, id: pyrosetta.rosetta.utility.vector1_unsigned_long, create_rotamers: bool, ligand_chain: str) -> pyrosetta.rosetta.core.pose.Pose

generates a smiles representation for the id and calls create_ligand_pose with smiles

C++: protocols::ligand_evolution::FragmentLibrary::create_ligand_pose(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, bool, char) const –> class std::shared_ptr<class core::pose::Pose>

create_ligand_pose(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, smiles: str, create_rotamers: bool, ligand_chain: str) -> pyrosetta.rosetta.core.pose.Pose

generates a new residue represented by a given ligand code and adds it to a detached copy of the internally saved pose object

C++: protocols::ligand_evolution::FragmentLibrary::create_ligand_pose(const std::string &, bool, char) const –> class std::shared_ptr<class core::pose::Pose>

get_similar_reagents(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reagent_id: int, reaction_id: int, position: int) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_double_t¶

Searches for similar reagents within a given reaction and position

C++: protocols::ligand_evolution::FragmentLibrary::get_similar_reagents(unsigned long, unsigned long, unsigned long) const –> class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > >

identifier_to_smiles(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, identifier: pyrosetta.rosetta.utility.vector1_unsigned_long) → str¶

Generates a new molecule with rdkit reaction and returns its smiles representation

C++: protocols::ligand_evolution::FragmentLibrary::identifier_to_smiles(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> std::string

initialize_from_options(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, options: protocols::ligand_evolution::EvolutionOptions, external_scoring: int, rank: int) → None¶: C++: protocols::ligand_evolution::FragmentLibrary::initialize_from_options(class std::shared_ptr<class protocols::ligand_evolution::EvolutionOptions>, unsigned long, unsigned long) –> void

load_data(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_file_path: str, reagent_file_path: str, rank: int) → None¶

Loads smirks reaction file and all reagents in the same folder

C++: protocols::ligand_evolution::FragmentLibrary::load_data(const std::string &, const std::string &, unsigned long) –> void

load_smiles(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, path_to_data: str) → None¶

Loads external smiles for later scoring from file

C++: protocols::ligand_evolution::FragmentLibrary::load_smiles(const std::string &) –> void

max_positions(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) → int¶

Returns the number of maximum positions for all reactions used

C++: protocols::ligand_evolution::FragmentLibrary::max_positions() const –> unsigned long

n_unscored_smiles(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) → int¶

Returns the number of saved external smiles that should be scored

C++: protocols::ligand_evolution::FragmentLibrary::n_unscored_smiles() const –> unsigned long

random_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Simple function to generate a completely random ligand

C++: protocols::ligand_evolution::FragmentLibrary::random_ligand() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

random_reaction(*args, **kwargs)¶

Overloaded function.

random_reaction(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) -> int

Returns a random reaction index weighted for size of possible molecules

C++: protocols::ligand_evolution::FragmentLibrary::random_reaction() const –> unsigned long

random_reaction(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, exclude: pyrosetta.rosetta.std.set_unsigned_long_t) -> int

Returns a random reaction that is not included in exclude weighted for size of possible molecules

C++: protocols::ligand_evolution::FragmentLibrary::random_reaction(const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &) const –> unsigned long

reaction_id(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_id: int) → str¶

Returns the id of this reaction

C++: protocols::ligand_evolution::FragmentLibrary::reaction_id(unsigned long) const –> std::string

reaction_name_to_index(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_name: str) → int¶

Returns the used reaction index for a given reaction name. Returns 0 if not found.

C++: protocols::ligand_evolution::FragmentLibrary::reaction_name_to_index(const std::string &) const –> unsigned long

reaction_positions(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_id: int) → int¶

Returns for a given reaction the number of positions used

C++: protocols::ligand_evolution::FragmentLibrary::reaction_positions(unsigned long) const –> unsigned long

reactions_size(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) → int¶

Returns the number of reactions

C++: protocols::ligand_evolution::FragmentLibrary::reactions_size() const –> unsigned long

reagent_id(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reagent_id: int) → str¶

Returns the id of this reagent

C++: protocols::ligand_evolution::FragmentLibrary::reagent_id(unsigned long) const –> std::string

reagent_name_to_index(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_index: int, position: int, reagent_name: str) → int¶

Returns the index for a given reagent. Returns 0 if not found.

C++: protocols::ligand_evolution::FragmentLibrary::reagent_name_to_index(unsigned long, unsigned long, const std::string &) const –> unsigned long

reagents_size(*args, **kwargs)¶

Overloaded function.

reagents_size(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) -> int

Returns the total number of reagents

C++: protocols::ligand_evolution::FragmentLibrary::reagents_size() const –> unsigned long

reagents_size(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_index: int) -> int

Returns the total number of reagents for the given reaction

C++: protocols::ligand_evolution::FragmentLibrary::reagents_size(unsigned long) const –> unsigned long

reagents_size(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, reaction_index: int, position: int) -> int

Returns the number of reagents at one specific position in the given reaction

C++: protocols::ligand_evolution::FragmentLibrary::reagents_size(unsigned long, unsigned long) const –> unsigned long

run_reaction(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, identifier: pyrosetta.rosetta.utility.vector1_unsigned_long) → str¶

Runs the reaction specified by the ligand identifier and returns the resulting rdkit molecule

C++: protocols::ligand_evolution::FragmentLibrary::run_reaction(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> std::string

set_pose(self: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Sets the internally used pose for ligand creation

C++: protocols::ligand_evolution::FragmentLibrary::set_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

Returns the Tanimoto Similarity based on RDKit Morgan fingerprints for two given ligands. The fingerprints are either calculated or retrieved if previously calculated

C++: protocols::ligand_evolution::FragmentLibrary::similarity(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> double

class pyrosetta.rosetta.protocols.ligand_evolution.IdentityFactory¶

Bases: OffspringFactory

Take a single individual, and returns a desired number of point mutated individuals based on the input one

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.IdentityFactory, parents: pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual, : int) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Simply copies and returns all individuals. N_offspring won’t be used here

C++: protocols::ligand_evolution::IdentityFactory::apply(const class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &, unsigned long) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.IdentityFactory) → str¶

Returns the name of this mutator

C++: protocols::ligand_evolution::IdentityFactory::name() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.Individual¶

Bases: pybind11_object

The individual holds all information about a single solution in an evolutionary optimization process

_pybind11_conduit_v1_()¶

id(*args, **kwargs)¶

Overloaded function.

id(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual, id: int) -> bool

Sets the id for this individual. Returns true if a new id was set

C++: protocols::ligand_evolution::Individual::id(unsigned long) –> bool

id(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) -> int

Returns the id of this individual

C++: protocols::ligand_evolution::Individual::id() const –> unsigned long

identifier(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Returns the LigandIdentifier of this solution

C++: protocols::ligand_evolution::Individual::identifier() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

is_scored(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → bool¶

Returns true only if the individual was scored before

C++: protocols::ligand_evolution::Individual::is_scored() const –> bool

parents(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → pyrosetta.rosetta.utility.vector1_unsigned_long¶

Returns this individuals parents ids

C++: protocols::ligand_evolution::Individual::parents() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual, name: str) -> float

Returns the score for the given string.

C++: protocols::ligand_evolution::Individual::score(const std::string &) const –> double

score(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual, name: str, score: float) -> None

Sets the score according to the given string.

C++: protocols::ligand_evolution::Individual::score(const std::string &, double) –> void

score(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) -> float

Returns the total score used by the evolutionary optimization

C++: protocols::ligand_evolution::Individual::score() const –> double

score(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual, score: float) -> None

Sets the total score used by the evolutionary optimization

C++: protocols::ligand_evolution::Individual::score(double) –> void

score_terms(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → pyrosetta.rosetta.std.map_std_string_double¶

Read only access to all raw score terms

C++: protocols::ligand_evolution::Individual::score_terms() const –> const class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > > &

type_of_birth(self: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → str¶

Returns this individuals type of birth

C++: protocols::ligand_evolution::Individual::type_of_birth() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.Mutator¶

Bases: OffspringFactory

Take a single individual, and returns a desired number of point mutated individuals based on the input one

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.Mutator, parents: pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual, n_offspring: int) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Accepts a list of parents and creates n_offspring mutants

Based on the internal values this mutation process changes either one of the reagents or the reaction and maps offspring to the closest ligand

C++: protocols::ligand_evolution::Mutator::apply(const class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &, unsigned long) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.Mutator) → str¶

Returns the name of this mutator

C++: protocols::ligand_evolution::Mutator::name() const –> const std::string &

set_max_similarity(self: pyrosetta.rosetta.protocols.ligand_evolution.Mutator, max_similarity: float) → None¶

Sets the maximum similarity for mutations

C++: protocols::ligand_evolution::Mutator::set_max_similarity(double) –> void

set_min_similarity(self: pyrosetta.rosetta.protocols.ligand_evolution.Mutator, min_similarity: float) → None¶

Sets the minimum similarity for mutations

C++: protocols::ligand_evolution::Mutator::set_min_similarity(double) –> void

class pyrosetta.rosetta.protocols.ligand_evolution.OffspringFactory¶

Bases: pybind11_object

: An abstract class to give an interface for producing offspring from individuals

comming soon.

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.OffspringFactory, parents: pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual, n_offspring: int) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Virtual function to wrap offspring production. Allows for input of any number of individuals and returns n offsprings

C++: protocols::ligand_evolution::OffspringFactory::apply(const class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &, unsigned long) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.OffspringFactory) → str¶

Returns the name of this factory

C++: protocols::ligand_evolution::OffspringFactory::name() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.Population¶

Bases: pybind11_object

@ Summarizes and contains all Individuals of one generation

_pybind11_conduit_v1_()¶

add_individual(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, individual: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → None¶

Adds an individual to this population and sets its id

C++: protocols::ligand_evolution::Population::add_individual(const class protocols::ligand_evolution::Individual &) –> void

add_individuals(*args, **kwargs)¶

Overloaded function.

add_individuals(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, new_individuals: pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual) -> None

Adds new (and potentially unscored individuals to the population)

C++: protocols::ligand_evolution::Population::add_individuals(const class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &) –> void

add_individuals(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, new_individuals: pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t) -> None

Adds new individuals based on provided LigandIdentifiers

C++: protocols::ligand_evolution::Population::add_individuals(const class utility::vector1<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::allocator<class utility::vector1<unsigned long, class std::allocator<unsigned long> > > > &) –> void

add_random(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, n_random_individuals: int, lib: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary) → None¶

Adds random individuals to a population

C++: protocols::ligand_evolution::Population::add_random(unsigned long, const class protocols::ligand_evolution::FragmentLibrary &) –> void

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

expose_generation_log(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) → pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t¶

For debugging and benchmarking purpose to observe population development

C++: protocols::ligand_evolution::Population::expose_generation_log() const –> const class utility::vector1<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::allocator<class utility::vector1<unsigned long, class std::allocator<unsigned long> > > > &

expose_inheritance_graph(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t¶

For debugging and benchmarking purpose to observe population development

C++: protocols::ligand_evolution::Population::expose_inheritance_graph() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

generation(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) → int¶

Returns the current generation

C++: protocols::ligand_evolution::Population::generation() const –> unsigned long

individual(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, index: int) → pyrosetta.rosetta.protocols.ligand_evolution.Individual¶

Non-const access specific individual

C++: protocols::ligand_evolution::Population::individual(unsigned long) –> class protocols::ligand_evolution::Individual &

individuals(*args, **kwargs)¶

Overloaded function.

individuals(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) -> pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual

Expose the individuals vector for normal iterator access

C++: protocols::ligand_evolution::Population::individuals() –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &

individuals(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, indices: pyrosetta.rosetta.utility.vector1_unsigned_long) -> pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual

Returns a copy of selected individuals

C++: protocols::ligand_evolution::Population::individuals(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

initialize_from_evotoptions(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, options: protocols::ligand_evolution::EvolutionOptions, library: pyrosetta.rosetta.protocols.ligand_evolution.FragmentLibrary, scorer: pyrosetta.rosetta.protocols.ligand_evolution.Scorer) → None¶

initializes setting from options object

C++: protocols::ligand_evolution::Population::initialize_from_evotoptions(const class protocols::ligand_evolution::EvolutionOptions &, const class protocols::ligand_evolution::FragmentLibrary &, const class protocols::ligand_evolution::Scorer &) –> void

is_sorted(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) → bool¶

Returns true if the individuals are sorted with lowest (and therefore best) score first

C++: protocols::ligand_evolution::Population::is_sorted() –> bool

next_generation(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, selector: pyrosetta.rosetta.protocols.ligand_evolution.Selector) → None¶

Removes unselected individuals, raises the generation counter and sorts individuals

C++: protocols::ligand_evolution::Population::next_generation(const class protocols::ligand_evolution::Selector &) –> void

remove_individuals(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, indices: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Removes individuals with the given index and returns them

C++: protocols::ligand_evolution::Population::remove_individuals(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

replace_population(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, individuals: pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual) → None¶

Replaces the internal population with a new one

C++: protocols::ligand_evolution::Population::replace_population(const class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> > &) –> void

set_supported_size(self: pyrosetta.rosetta.protocols.ligand_evolution.Population, supported_size: int) → None¶

Sets the supported size of this population. It will get reduced to this size through selective pressure

C++: protocols::ligand_evolution::Population::set_supported_size(unsigned long) –> void

size(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) → int¶

Returns the size of this population

C++: protocols::ligand_evolution::Population::size() const –> unsigned long

sort(self: pyrosetta.rosetta.protocols.ligand_evolution.Population) → None¶

Sorts all individuals depending on their score

C++: protocols::ligand_evolution::Population::sort() –> void

class pyrosetta.rosetta.protocols.ligand_evolution.Reaction¶

Bases: pybind11_object

Internal class to handle reaction information more easily

_pybind11_conduit_v1_()¶

add_reagent(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction, pos: int, reagent_idx: int) → None¶: C++: protocols::ligand_evolution::Reaction::add_reagent(unsigned long, unsigned long) –> void

calculate_possible_molecules(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction) → int¶

Calculates and returns how many molecules possible with this reaction.

C++: protocols::ligand_evolution::Reaction::calculate_possible_molecules() –> unsigned long

n_positions(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction) → int¶

Returns the number positions with this reaction

C++: protocols::ligand_evolution::Reaction::n_positions() const –> unsigned long

name(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction) → str¶: C++: protocols::ligand_evolution::Reaction::name() const –> std::string

possible_molecules(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction) → int¶: C++: protocols::ligand_evolution::Reaction::possible_molecules() const –> unsigned long

random_reagent_index(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction, position: int) → int¶

returns the index of a random reagent in a FragmentLibraries reagents_ usable for the given position in this reaction

C++: protocols::ligand_evolution::Reaction::random_reagent_index(unsigned long) const –> unsigned long

reac(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction) → RDKit::ChemicalReaction¶: C++: protocols::ligand_evolution::Reaction::reac() –> class std::shared_ptr<class RDKit::ChemicalReaction>

reagents(self: pyrosetta.rosetta.protocols.ligand_evolution.Reaction, pos: int) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::ligand_evolution::Reaction::reagents(unsigned long) const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

class pyrosetta.rosetta.protocols.ligand_evolution.Reagent¶

Bases: pybind11_object

Internal class to handle reagent information more easily

_pybind11_conduit_v1_()¶

fingerprint(self: pyrosetta.rosetta.protocols.ligand_evolution.Reagent) → RDKit::SparseIntVect<unsigned int>¶: C++: protocols::ligand_evolution::Reagent::fingerprint() –> class std::shared_ptr<class RDKit::SparseIntVect<unsigned int> >

name(self: pyrosetta.rosetta.protocols.ligand_evolution.Reagent) → str¶: C++: protocols::ligand_evolution::Reagent::name() const –> std::string

class pyrosetta.rosetta.protocols.ligand_evolution.RouletteSelector¶

Bases: Selector

Selects only the best scored individuals

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.RouletteSelector, population: pyrosetta.rosetta.protocols.ligand_evolution.Population, size: int, remove: bool) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Returns the indices of the size selected individuals from population with a roulette wheel selection

C++: protocols::ligand_evolution::RouletteSelector::apply(class protocols::ligand_evolution::Population &, unsigned long, bool) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

consider_positive(self: pyrosetta.rosetta.protocols.ligand_evolution.RouletteSelector, consider_positive: bool) → None¶

Switch whether positive fitness should be considered or not. If they are considered, this changes the proportions of all other fitness a bit!

C++: protocols::ligand_evolution::RouletteSelector::consider_positive(bool) –> void

name(self: pyrosetta.rosetta.protocols.ligand_evolution.RouletteSelector) → str¶

Return the name of this selector

C++: protocols::ligand_evolution::RouletteSelector::name() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.Scorer¶

Bases: pybind11_object

: The %Scorer computes the score of each %Individual in a %Population. It applies a list of movers, calculates a variety of score terms and combines them. The scorer also collects statistics and summarizes information.

_pybind11_conduit_v1_()¶

add_mover(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, mover: pyrosetta.rosetta.protocols.moves.Mover) → None¶

Adds a mover

C++: protocols::ligand_evolution::Scorer::add_mover(const class std::shared_ptr<class protocols::moves::Mover> &) –> void

check_memory(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool¶

Checks if score for this ligand is available in memory and loads it if possible.

C++: protocols::ligand_evolution::Scorer::check_memory(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> bool

expose_id_memory(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer) → pyrosetta.rosetta.std.map_utility_vector1_unsigned_long_std_allocator_unsigned_long_t_std_set_unsigned_long_t_std_less_utility_vector1_unsigned_long_std_allocator_unsigned_long_t_std_allocator_std_pair_const_utility_vector1_unsigned_long_std_allocator_unsigned_long_std_set_unsigned_long_t¶

For debugging and benchmarking purposes

C++: protocols::ligand_evolution::Scorer::expose_id_memory() const –> const class std::map<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >, struct std::less<class utility::vector1<unsigned long, class std::allocator<unsigned long> > >, class std::allocator<struct std::pair<const class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > > > > &

get_best_loaded(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, size: int) → pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t¶

Returns a list of LigandIdentifiers for loaded scores sorted by their main term score

Sets how many identifiers should be returned. If <= 0, all will be returned

C++: protocols::ligand_evolution::Scorer::get_best_loaded(unsigned long) const –> class utility::vector1<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::allocator<class utility::vector1<unsigned long, class std::allocator<unsigned long> > > >

get_raw_scores(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, identifier: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_double¶

Returns the raw scores of an identifier for mpi communication

C++: protocols::ligand_evolution::Scorer::get_raw_scores(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> class utility::vector1<double, class std::allocator<double> >

get_scores(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.std.map_std_string_double¶

Returns all scores in a map with a string identifier

C++: protocols::ligand_evolution::Scorer::get_scores(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > > &

has_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer) → bool¶

Checks if a ligand is currently set

C++: protocols::ligand_evolution::Scorer::has_ligand() const –> bool

initialize_from_options(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, options: protocols::ligand_evolution::EvolutionOptions, rosetta_script: pyrosetta.rosetta.protocols.rosetta_scripts.XmlObjects, rank: int) → None¶: C++: protocols::ligand_evolution::Scorer::initialize_from_options(class std::shared_ptr<const class protocols::ligand_evolution::EvolutionOptions>, class std::shared_ptr<const class protocols::rosetta_scripts::XmlObjects>, unsigned long) –> void

is_scored(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool¶

Returns true if the ligand was already scored

C++: protocols::ligand_evolution::Scorer::is_scored(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

load_scores(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, path: str) → None¶

Loads scores for combinations of reagents and reactions from file. These are used during the run instead of rescoring. Format is the output format of RLE.

C++: protocols::ligand_evolution::Scorer::load_scores(const std::string &) –> void

n_score_terms(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer) → int¶

Return how many score terms are calculated

C++: protocols::ligand_evolution::Scorer::n_score_terms() const –> unsigned long

next_step(*args, **kwargs)¶

Overloaded function.

next_step(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer) -> bool
next_step(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, save_n_scores: int) -> bool

Performs the next scoring step on the current individual. Returns true, if this was the last step

C++: protocols::ligand_evolution::Scorer::next_step(unsigned long) –> bool

save_external_scoring_results(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, rank: int) → None¶

Writes multiple scores per ligand to disk

C++: protocols::ligand_evolution::Scorer::save_external_scoring_results(unsigned long) –> void

save_results(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer) → None¶

Writes all results to disk

C++: protocols::ligand_evolution::Scorer::save_results() const –> void

score_individual(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, individual: pyrosetta.rosetta.protocols.ligand_evolution.Individual) → None¶

Checks if this individuals ligand was already scores, scores it if not, and sets the score for the individual

C++: protocols::ligand_evolution::Scorer::score_individual(class protocols::ligand_evolution::Individual &) –> void

score_ligand(*args, **kwargs)¶

Overloaded function.

score_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None
score_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long, smiles: str) -> None
score_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long, smiles: str, save_n_scores: int) -> None

Sets the current ligand and calls all steps to score it completely

C++: protocols::ligand_evolution::Scorer::score_ligand(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const std::string &, unsigned long) –> void

score_population(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, pop: protocols::ligand_evolution::Population) → None¶

Sets the score for all individuals in the population, calculates it where needed

If the same ligand is multiple times present within the population, each occures after the first gets an increasing penalty.

C++: protocols::ligand_evolution::Scorer::score_population(class protocols::ligand_evolution::Population &) –> void

set_base_similarity_penalty(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, base_penalty: float) → None¶

Sets the penalty for ligands which are appear more than once within a population

The penalty is a relative fraction of the current main score for each ligand. It starts at 0 and increases with each additional ligand by the base penalty

C++: protocols::ligand_evolution::Scorer::set_base_similarity_penalty(double) –> void

set_ligand(*args, **kwargs)¶

Overloaded function.

set_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None
set_ligand(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, ligand: pyrosetta.rosetta.utility.vector1_unsigned_long, smiles: str) -> None

Sets the current ligand on which should be worked

C++: protocols::ligand_evolution::Scorer::set_ligand(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const std::string &) –> void

set_main_term(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, score_term: str) → None¶

Sets which term should be used for optimization

C++: protocols::ligand_evolution::Scorer::set_main_term(const std::string &) –> void

set_pose_path(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, path: str) → None¶

Sets the path where poses should be saved. Leave it empty to save in the current working directory

C++: protocols::ligand_evolution::Scorer::set_pose_path(const std::string &) –> void

set_raw_scores(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, identifier: pyrosetta.rosetta.utility.vector1_unsigned_long, raw_scores: float) → None¶

Transforms raw double scores into a proper map and calls set_scores

Expects scores in the same order as score_terms

C++: protocols::ligand_evolution::Scorer::set_raw_scores(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double *) –> void

set_score_function(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, score_function: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Sets the desired score function

C++: protocols::ligand_evolution::Scorer::set_score_function(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_scores(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, identifier: pyrosetta.rosetta.utility.vector1_unsigned_long, scores: pyrosetta.rosetta.std.map_std_string_double) → None¶

Sets all score terms for an identifier if not set yet.

This functions expects that the scores were calculated by another instance of a Scorer which took care of all runs and wrote the best pose to disk

C++: protocols::ligand_evolution::Scorer::set_scores(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > > &) –> void

set_similarity_penalty_threshold(self: pyrosetta.rosetta.protocols.ligand_evolution.Scorer, threshold: float) → None¶: C++: protocols::ligand_evolution::Scorer::set_similarity_penalty_threshold(double) –> void

class pyrosetta.rosetta.protocols.ligand_evolution.Selector¶

Bases: pybind11_object

: An abstract class to give an interface for subset selection of %Population

comming soon.

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.Selector, population: protocols::ligand_evolution::Population, size: int, remove: bool) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Applies the specified rules to create a list of indices of selected individuals

C++: protocols::ligand_evolution::Selector::apply(class protocols::ligand_evolution::Population &, unsigned long, bool) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.Selector) → str¶

Return the name of this selector

C++: protocols::ligand_evolution::Selector::name() const –> const std::string &

class pyrosetta.rosetta.protocols.ligand_evolution.TournamentSelector¶

Bases: Selector

Selects only the best scored individuals

_pybind11_conduit_v1_()¶

apply(self: pyrosetta.rosetta.protocols.ligand_evolution.TournamentSelector, population: pyrosetta.rosetta.protocols.ligand_evolution.Population, size: int, remove: bool) → pyrosetta.rosetta.utility.vector1_protocols_ligand_evolution_Individual¶

Returns the indices of the n_select tournament winning individuals in population.

C++: protocols::ligand_evolution::TournamentSelector::apply(class protocols::ligand_evolution::Population &, unsigned long, bool) const –> class utility::vector1<class protocols::ligand_evolution::Individual, class std::allocator<class protocols::ligand_evolution::Individual> >

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

name(self: pyrosetta.rosetta.protocols.ligand_evolution.TournamentSelector) → str¶

Return the name of this selector

C++: protocols::ligand_evolution::TournamentSelector::name() const –> const std::string &

set_probability(self: pyrosetta.rosetta.protocols.ligand_evolution.TournamentSelector, probability: float) → None¶

Sets the probability that the tournament winner accepts

C++: protocols::ligand_evolution::TournamentSelector::set_probability(double) –> void

set_tournament_size(self: pyrosetta.rosetta.protocols.ligand_evolution.TournamentSelector, size: int) → None¶

Sets the size for each tournament

C++: protocols::ligand_evolution::TournamentSelector::set_tournament_size(unsigned long) –> void