Loading...
Searching...
No Matches
BALL::ScoringFunction Class Reference

`#include <BALL/SCORING/COMMON/scoringFunction.h>`

Inheritance diagram for BALL::ScoringFunction:

## Classes

struct | Option
struct | Default
struct | Result

## Public Member Functions

| ScoringFunction ()
| ScoringFunction (const ScoringFunction &sf)
| ScoringFunction (AtomContainer &receptor, AtomContainer &ligand)
| ScoringFunction (AtomContainer &receptor, AtomContainer &ligand, const Options &options)
| ScoringFunction (AtomContainer &receptor, AtomContainer &ligand, Options &options)
| ScoringFunction (AtomContainer &receptor, Vector3 &hashgrid_origin, Options &options)
virtual | ~ScoringFunction ()
virtual void | clear ()
ScoringFunction & | operator= (const ScoringFunction &sf)
bool | setup ()
bool | setup (AtomContainer &receptor, AtomContainer &ligand)
bool | setup (AtomContainer &receptor, AtomContainer &ligand, const Options &options)
void | setMaximumNumberOfErrors (Size nr)
Size | getMaximumNumberOfErrors () const
void | setFirstMolecule (AtomContainer &molecule1)
AtomContainer * | getFirstMolecule () const
void | setSecondMolecule (AtomContainer &molecule2)
AtomContainer * | getSecondMolecule () const
void | setReceptor (AtomContainer &receptor)
AtomContainer * | getReceptor () const
void | setLigand (AtomContainer &ligand)
AtomContainer * | getLigand () const
void | setIntercept (double intercept)
double | getIntercept () const
void | setBaseFunction (ScoringBaseFunction &base_function)
| Set the instance of BaseFunction for the scoring function.
ScoringBaseFunction * | getBaseFunction () const
void | insertComponent (ScoringComponent *component)
void | insertComponent (ScoringComponent *component, float coefficient)
void | removeComponent (const ScoringComponent *component)
void | removeComponent (const String &name)
void | setCoefficient (const ScoringComponent *component, float coefficient)
void | setCoefficient (const String &name, float coefficient)
bool | getCoefficient (const ScoringComponent *component, float &coefficient) const
bool | getCoefficient (const String &name, float &coefficient) const
ScoringComponent * | getComponent (const String &name) const
ScoringComponent * | getComponent (const Size index) const
double | calculateScore ()
const HashSet< const Atom * > & | getUnassignedAtoms () const
HashSet< const Atom * > & | getUnassignedAtoms ()
double | getExpEnergyStddev ()
void | enableStoreInteractionsOnlyForPhContraints ()
String | convertTime (double seconds)
virtual void | update ()
virtual double | updateScore ()
virtual void | printResult (bool detail=0)
void | getScoreContributions (vector< double > &score_contributions, vector< String > &names)
String | getEquation ()
void | enableStoreInteractions (bool b=true)
String | getName ()
int | getBurialDepthScale ()
String | valueToString (double value)
void | unsetTrainingParameters ()
void | setNormalizationParameters (double stddev, double mean)
const HashGrid3< Atom * > * | getHashGrid ()
const Vector3 & | getLigandCenter () const
double | getLigandRadius () const
bool | storeInteractionsEnabled ()
virtual int | getNoNeighboringReceptorAtoms ()
int | getNoLigandAtoms ()
Options | getOptions ()
Options * | getOptionsToModify ()
void | createStaticLigandFragments ()
const vector< Bond * > * | getRotatableLigandBonds () const
const vector< StaticLigandFragment * > * | getStaticLigandFragments () const
bool | hasFlexibleResidues ()
void | setFlexibleResidues (const std::set< Residue * > &flexible_residues)
bool | assignRotamer (Residue *residue, ResidueRotamerSet *rotamer_set, const Rotamer *rotamer)
void | resetFlexibleResidues ()
Size | countNeighboringReceptorAtoms (const Atom *atom, double distance_threshold, bool onePerCell=0, int *number_of_overlaps=0) const
void | resetResiduePositions (Residue *residue, list< Vector3 > &old_positions)
double | getScore ()
const std::map< Atom *, int > * | getAtomFragmentMap ()

## Static Public Member Functions

static HashGrid3< Atom * > * | initializeHashGrid (AtomContainer *sys, Vector3 &center, double &resolution, int hashgrid_size)
static void | getDefaultOptions (Options &options)

## Public Attributes

list< Constraint * > | constraints {}

## Static Public Attributes

static const char * | SUBCATEGORY_NAME

## Protected Member Functions

void | setName (String name)
void | updateComponent (int id, AtomPairList *)
Vector3 | calculateGeometricalCenter (AtomContainer *s, int *no_ligand_atoms=NULL)
double | calculateMoleculeRadius (AtomContainer *sys, Vector3 &center)
void | setupFlexibleResidues_ ()
virtual void | setupReferenceLigand ()
int | checkForAtomOverlaps (const AtomPairVector *pair_vector)
AtomPairVector * | createNonbondedPairVector (HashGrid3< Atom * > *hashgrid, int &overlaps, bool rec_lig, bool check_fragments=0, bool intra_fragment=0)
AtomPairVector * | createLigandNonbondedPairVector (bool intra_fragment, int &overlaps)
bool | hasPharmacophoreConstraints_ ()
void | clearStoredInteractions_ ()
double | calculateConstraintsScore ()
void | enableInteractionComponents_ (const list< String > &type_names)
virtual double | getES ()
void | enableAllComponents_ ()
void | fetchStaticLigandFragment (Atom *a1, int index)
int | countCovalentBonds (const Atom *atom, int threshold=-1)
virtual void | createAllLigandNonBondedPairs ()
virtual double | calculateStaticLigandFragmentEnergy ()
bool | isPeptideBond (const Bond *bond) const

## Protected Attributes

String | name_ {""}
Options | options_ {}
AtomContainer * | receptor_ {nullptr}
AtomContainer * | ligand_ {nullptr}
double | score_ {0.0}
double | intercept_ {0.0}
ScoringBaseFunction * | base_function_ {nullptr}
vector< ScoringComponent * > | scoring_components_ {}
HashSet< const Atom * > | unassigned_atoms_ {}
Size | max_number_of_errors_ {0}
Size | number_of_errors_ {0}
double | ligand_radius_ {0.0}
int | ligand_atoms_ {0}
Vector3 | ligand_center_ {}
HashGrid3< Atom * > * | hashgrid_ {nullptr}
HashGrid3< Atom * > * | all_residues_hashgrid_ {nullptr}
HashGrid3< Atom * > * | static_residues_hashgrid_ {nullptr}
HashGrid3< Atom * > * | flexible_residues_hashgrid_ {nullptr}
double | resolution_ {0.0}
std::map< Atom *, int > | atoms_to_fragments_ {}
int | reference_neighbors_ {0}
int | neighboring_target_atoms_ {0}
int | misplaced_ligand_atoms_ {0}
int | hashgrid_search_radius_ {0}
double | nonbonded_cutoff_ {0.0}
double | nonbonded_cutoff_2_ {0.0}
bool | ignore_h_clashes_ {false}
int | overlaps_ {0}
int | ligand_intramol_overlaps_ {0}
double | allowed_intermolecular_overlap_ {0.0}
double | allowed_intramolecular_overlap_ {0.0}
double | neighbor_cutoff_2_ {0.0}
vector< StaticLigandFragment * > | static_ligand_fragments_ {}
bool | store_interactions_ {false}
bool | store_interactions_phC_only_ {false}
AtomPairVector * | all_ligand_nonbonded_ {nullptr}
double | conformation_scale_ {0.0}
bool | use_all_lig_nonb_ {false}
bool | use_static_lig_fragments_ {false}
int | burial_depth_scale_ {0}
double | exp_energy_stddev_ {0.0}
double | exp_energy_mean_ {0.0}
std::set< Residue * > | flexible_residues_ {}
Result | result_ {}
double | static_ligand_energy_ {0.0}
vector< Bond * > | rotatable_ligand_bonds_ {}
list< list< Vector3 > > | flexres_org_positions_ {}

## Friends

class | PharmacophoreConstraint
class | SideChainOptimizer

## Detailed Description

Definition at line 28 of file scoringFunction.h.

## Constructor & Destructor Documentation

## ScoringFunction() [1/6]

BALL::ScoringFunction::ScoringFunction | ( |  | ) |

## ScoringFunction() [2/6]

BALL::ScoringFunction::ScoringFunction | ( | const ScoringFunction & | sf | ) |

## ScoringFunction() [3/6]

BALL::ScoringFunction::ScoringFunction | ( | AtomContainer & | receptor,
|  | AtomContainer & | ligand )

## ScoringFunction() [4/6]

BALL::ScoringFunction::ScoringFunction | ( | AtomContainer & | receptor,
|  | AtomContainer & | ligand,
|  | const Options & | options )

## ScoringFunction() [5/6]

BALL::ScoringFunction::ScoringFunction | ( | AtomContainer & | receptor,
|  | AtomContainer & | ligand,
|  | Options & | options )

## ScoringFunction() [6/6]

BALL::ScoringFunction::ScoringFunction | ( | AtomContainer & | receptor,
|  | Vector3 & | hashgrid_origin,
|  | Options & | options )

Constructor for use without reference ligand

Parameters

  hashgrid_origin | Origin of the HashGrid that will hold receptor atoms as potential interaction partners.

## ~ScoringFunction()

virtual BALL::ScoringFunction::~ScoringFunction | ( |  | ) |

virtual

## Member Function Documentation

## assignRotamer()

bool BALL::ScoringFunction::assignRotamer | ( | Residue * | residue,
|  | ResidueRotamerSet * | rotamer_set,
|  | const Rotamer * | rotamer )

Assign the given rotamer to the specified residue.
After applying the new rotamer, it is checked whether it overlaps with any other receptor residues. If this is the case, the previously used rotamer will re-applied and zero will be returned. Else, one will be returned by this function. The hash_grid_ of this ScoringFunction that keeps track of all receptor atoms will be automatically updated.

## calculateConstraintsScore()

double BALL::ScoringFunction::calculateConstraintsScore | ( |  | ) |

protected

Calculates penalty-scores for all defined Contraints and returns the sum.

## calculateGeometricalCenter()

Vector3 BALL::ScoringFunction::calculateGeometricalCenter | ( | AtomContainer * | s,
|  | int * | no_ligand_atoms = NULL )

protected

Calculates the geometrical center of the given structure

Parameters

  no_ligand_atoms | if specified, the number of atoms of the current ligand candidate is saved here.

## calculateMoleculeRadius()

double BALL::ScoringFunction::calculateMoleculeRadius | ( | AtomContainer * | sys,
|  | Vector3 & | center )

protected

Calculates the radius of a given structure, i.e. the maximal distance from its geometrical center.

## calculateScore()

double BALL::ScoringFunction::calculateScore | ( |  | ) |

## calculateStaticLigandFragmentEnergy()

virtual double BALL::ScoringFunction::calculateStaticLigandFragmentEnergy | ( |  | ) |

protected virtual

Calculates the energy within the StaticLigandFragments only!
This needs to be done only once for each ligand candidate.

## checkForAtomOverlaps()

int BALL::ScoringFunction::checkForAtomOverlaps | ( | const AtomPairVector * | pair_vector | ) |

protected

Check how many of the atom pairs in the given AtomPairVector clash with each other.

## clear()

virtual void BALL::ScoringFunction::clear | ( |  | ) |

virtual

Reimplemented in BALL::SLICKEnergy, and BALL::SLICKScore.

## clearStoredInteractions_()

void BALL::ScoringFunction::clearStoredInteractions_ | ( |  | ) |

protected

Clears the MolecularInteractions saved for each ligand- and receptor-atom.

## convertTime()

String BALL::ScoringFunction::convertTime | ( | double | seconds | ) |

Converts the given seconds (e.g. result of BALL::Timer::getClockTime()) into the appropriate unit and output a String containing value and unit.

## countCovalentBonds()

int BALL::ScoringFunction::countCovalentBonds | ( | const Atom * | atom,
|  | int | threshold = -1 )

protected

Returns the number of covalent bonds of the given atom

Parameters

  threshold | if specified, it is only checked whether there are at least so many covalent bonds.

## countNeighboringReceptorAtoms()

Size BALL::ScoringFunction::countNeighboringReceptorAtoms | ( | const Atom * | atom,
|  | double | distance_threshold,
|  | bool | onePerCell = 0,
|  | int * | number_of_overlaps = 0 ) const

Count the number of receptor atoms that have a distance <= distance_threshold to the specified atom.

Parameters

  onePerCell | If true, only one receptor atom within each hashgrid cell will be taken into account, i.e. the number of neighboring nonempty cells is counted.

## createAllLigandNonBondedPairs()

virtual void BALL::ScoringFunction::createAllLigandNonBondedPairs | ( |  | ) |

protected virtual

Calculates all nonbonded pairs of ligand atoms, i.e. without using a cutoff. This way much time can be saved (for small+medium sized ligands) because the pairlist of the nonbonded comformation component will not be changed by future calls of update() for this ligand.

## createLigandNonbondedPairVector()

AtomPairVector * BALL::ScoringFunction::createLigandNonbondedPairVector | ( | bool | intra_fragment,
|  | int & | overlaps )

protected

Creates nonbonded pairs of ligand atoms.
If StaticLigandFragments are used, only atoms that are part of different StaticLigandFragments are searched. This way, time can be saved during updating the ForceFields, since the score/energy within each StaticLigandFragments will not change.

Parameters

  intra_fragment | if set to true (and check_fragment == 1), nonbonded interactions between atoms of the same fragment are searched instead. This is used to calculated the energy of all StaticLigandFragments once for each ligand candidate.
  overlaps | the number of atom overlaps will be added to this value

## createNonbondedPairVector()

AtomPairVector * BALL::ScoringFunction::createNonbondedPairVector | ( | HashGrid3< Atom * > * | hashgrid,
|  | int & | overlaps,
|  | bool | rec_lig,
|  | bool | check_fragments = 0,
|  | bool | intra_fragment = 0 )

protected

Creates a vector of pairs of ligand atoms and receptor atoms (or atoms of additional systems, e.g. water molecules).
The structure to which the interactions of the current ligand are to be search is represented by the given HashGrid.
The vector of nonbonded atom pairs created by this function is to be used to update the ScoringComponents.

Parameters

  rec_lig | determines whether interactions between ligand and receptor are sought. If this is the case, the checks that make sure that two atoms chosen as an atompair are no neighbors and are not identical can be skipped. This way, some time can be saved.
  check_fragment | if set to true it is is checked whether two atoms are not part of the same StaticLigandFragment
  intra_fragment | if set to true (and check_fragment == 1), nonbonded interactions between atoms of the same fragment are searched instead. This is used to calculated the energy of all StaticLigandFragments once for each ligand candidate.
  overlaps | the number of atom overlaps will be added to this value.

## createStaticLigandFragments()

void BALL::ScoringFunction::createStaticLigandFragments | ( |  | ) |

Creates StaticLigandFragments for the current ligand candidate. After this function has been called once for the current ligand candidate, conformation energy is only calculated anew between inter-fragment atom-pairs of this ligand candidate. This way, the speed of energy/score computation can be increased.

## enableAllComponents_()

void BALL::ScoringFunction::enableAllComponents_ | ( |  | ) |

protected

Enables all ScoringComponents.

## enableInteractionComponents_()

void BALL::ScoringFunction::enableInteractionComponents_ | ( | const list< String > & | type_names | ) |

protected

Enabled the ScoringComponents of the given types and disables all other ScoringComponents. Components that evaluate the intramolecular energy of the ligand will be disabled.

## enableStoreInteractions()

void BALL::ScoringFunction::enableStoreInteractions | ( | bool | b = true | ) |

Determines whether interactions calculated by this ScoringFunction should be saved to each ligand atom a in a->interactions. By default storing of interactions is disabled for new ScoringFunctions.

## enableStoreInteractionsOnlyForPhContraints()

void BALL::ScoringFunction::enableStoreInteractionsOnlyForPhContraints | ( |  | ) |

## fetchStaticLigandFragment()

void BALL::ScoringFunction::fetchStaticLigandFragment | ( | Atom * | a1,
|  | int | index )

protected

Fetches the StaticLigandFragments starting with a1.
This function is used by createStaticLigandFragments(), so that is does not need to be called directly.

Parameters

  already_processed_atoms | a temporary hashmap that will store already processed atoms.

## getAtomFragmentMap()

const std::map< Atom *, int > * BALL::ScoringFunction::getAtomFragmentMap | ( |  | ) |

## getBaseFunction()

ScoringBaseFunction * BALL::ScoringFunction::getBaseFunction | ( |  | ) | const

Return a pointer to the instance of BaseFunction used by this scoring function.

## getBurialDepthScale()

int BALL::ScoringFunction::getBurialDepthScale | ( |  | ) |

## getCoefficient() [1/2]

bool BALL::ScoringFunction::getCoefficient | ( | const ScoringComponent * | component,
|  | float & | coefficient ) const

Get the coefficient of a component. If there was no matching component, return false, ow return true.

## getCoefficient() [2/2]

bool BALL::ScoringFunction::getCoefficient | ( | const String & | name,
|  | float & | coefficient ) const

Get the coefficient of a component. If there was no matching component, return false, ow return true.

## getComponent() [1/2]

ScoringComponent * BALL::ScoringFunction::getComponent | ( | const Size | index | ) | const

Return a pointer to a component in the components vector.

## getComponent() [2/2]

ScoringComponent * BALL::ScoringFunction::getComponent | ( | const String & | name | ) | const

Return a pointer to a component in the components vector.

## getDefaultOptions()

void BALL::ScoringFunction::getDefaultOptions | ( | Options & | options | ) |

static

Stores the default options of this ScoringFunction in the given Option object.

## getEquation()

String BALL::ScoringFunction::getEquation | ( |  | ) |

Returns a string containing the equation of this ScoringFunction (as sum of over all ScoringComponents).

## getES()

virtual double BALL::ScoringFunction::getES | ( |  | ) |

protected virtual

Reimplemented in BALL::GridedMM, BALL::GridedPLP, BALL::MMScoring, BALL::PBScoring, and BALL::PLPScoring.

## getExpEnergyStddev()

double BALL::ScoringFunction::getExpEnergyStddev | ( |  | ) |

Returns the standard deviation of the experimentally determined binding free energy of the used training data set

## getFirstMolecule()

AtomContainer * BALL::ScoringFunction::getFirstMolecule | ( |  | ) | const

## getHashGrid()

const HashGrid3< Atom * > * BALL::ScoringFunction::getHashGrid | ( |  | ) |

## getIntercept()

double BALL::ScoringFunction::getIntercept | ( |  | ) | const

## getLigand()

AtomContainer * BALL::ScoringFunction::getLigand | ( |  | ) | const

Return the ligand of the complex (which is just the same as molecule2_).

## getLigandCenter()

const Vector3 & BALL::ScoringFunction::getLigandCenter | ( |  | ) | const

Returns geometrical center of the current ligand candidate.

## getLigandRadius()

double BALL::ScoringFunction::getLigandRadius | ( |  | ) | const

## getMaximumNumberOfErrors()

Size BALL::ScoringFunction::getMaximumNumberOfErrors | ( |  | ) | const

## getName()

String BALL::ScoringFunction::getName | ( |  | ) |

Return the name of this ScoringFunction.

## getNoLigandAtoms()

int BALL::ScoringFunction::getNoLigandAtoms | ( |  | ) |

Return the number of atoms of the current ligand.

## getNoNeighboringReceptorAtoms()

virtual int BALL::ScoringFunction::getNoNeighboringReceptorAtoms | ( |  | ) |

virtual

Returns the average number of receptor atoms neighboring each ligand atom as determined by the last call of update().

Reimplemented in BALL::GridBasedScoring.

## getOptions()

Options BALL::ScoringFunction::getOptions | ( |  | ) |

Return the options set for this scoring function.

## getOptionsToModify()

Options * BALL::ScoringFunction::getOptionsToModify | ( |  | ) |

Return pointer to the options set for this scoring function.

## getReceptor()

AtomContainer * BALL::ScoringFunction::getReceptor | ( |  | ) | const

Return the receptor of the complex (which is just the same as molecule1_).

## getRotatableLigandBonds()

const vector< Bond * > * BALL::ScoringFunction::getRotatableLigandBonds | ( |  | ) | const

## getScore()

double BALL::ScoringFunction::getScore | ( |  | ) |

Return the previously calculated score.

## getScoreContributions()

void BALL::ScoringFunction::getScoreContributions | ( | vector< double > & | score_contributions,
|  | vector< String > & | names )

## getSecondMolecule()

AtomContainer * BALL::ScoringFunction::getSecondMolecule | ( |  | ) | const

## getStaticLigandFragments()

const vector< StaticLigandFragment * > * BALL::ScoringFunction::getStaticLigandFragments | ( |  | ) | const

## getUnassignedAtoms() [1/2]

HashSet< const Atom * > & BALL::ScoringFunction::getUnassignedAtoms | ( |  | ) |

## getUnassignedAtoms() [2/2]

const HashSet< const Atom * > & BALL::ScoringFunction::getUnassignedAtoms | ( |  | ) | const

## hasFlexibleResidues()

bool BALL::ScoringFunction::hasFlexibleResidues | ( |  | ) |

## hasPharmacophoreConstraints_()

bool BALL::ScoringFunction::hasPharmacophoreConstraints_ | ( |  | ) |

protected

## initializeHashGrid()

HashGrid3< Atom * > * BALL::ScoringFunction::initializeHashGrid | ( | AtomContainer * | sys,
|  | Vector3 & | center,
|  | double & | resolution,
|  | int | hashgrid_size )

static

## insertComponent() [1/2]

void BALL::ScoringFunction::insertComponent | ( | ScoringComponent * | component | ) |

Add a scoring component to the scoring functions scoring_components_.

Parameters

  component | Scoring component to add.

## insertComponent() [2/2]

void BALL::ScoringFunction::insertComponent | ( | ScoringComponent * | component,
|  | float | coefficient )

Add a scoring component and its coefficient to the scoring functions scoring_components_.

Parameters

  component | Scoring component to add.
  coefficient | Coefficient associated with the added component.

## isPeptideBond()

bool BALL::ScoringFunction::isPeptideBond | ( | const Bond * | bond | ) | const

protected

Determines whether the given bond is a peptide bond and thereby not rotatable.

## operator=()

ScoringFunction & BALL::ScoringFunction::operator= | ( | const ScoringFunction & | sf | ) |

## printResult()

virtual void BALL::ScoringFunction::printResult | ( | bool | detail = 0 | ) |

virtual

Prints an explanation of the score as obtained by the last call of updateScore() to stdout

Parameters

  detail | If true, information about inidividual score-contributions is printed as well as the overview.

## removeComponent() [1/2]

void BALL::ScoringFunction::removeComponent | ( | const ScoringComponent * | component | ) |

Remove a component from the component list of this scoring function and delete it from memory. If there was no matching component, do nothing. Note that the user will get no feedback if there was no component removed.

## removeComponent() [2/2]

void BALL::ScoringFunction::removeComponent | ( | const String & | name | ) |

Remove a component from the component list of this scoring function and delete it from memory. If there was no matching component, do nothing. Note that the user will get no feedback if there was no component removed. Only the first occurrence of a name in the component list will be removed.

## resetFlexibleResidues()

void BALL::ScoringFunction::resetFlexibleResidues | ( |  | ) |

Resets flexible residues to the conformations observed in the input pdb-file.
This does only have any effect if optimization of flexible residues has been used before the call of this function.

## resetResiduePositions()

void BALL::ScoringFunction::resetResiduePositions | ( | Residue * | residue,
|  | list< Vector3 > & | old_positions )

## setBaseFunction()

void BALL::ScoringFunction::setBaseFunction | ( | ScoringBaseFunction & | base_function | ) |

Set the instance of BaseFunction for the scoring function.

## setCoefficient() [1/2]

void BALL::ScoringFunction::setCoefficient | ( | const ScoringComponent * | component,
|  | float | coefficient )

Set the coefficient of a component. If there was no matching component, do nothing. Note that the user will get no feedback if there was no coefficient set.

## setCoefficient() [2/2]

void BALL::ScoringFunction::setCoefficient | ( | const String & | name,
|  | float | coefficient )

Set the coefficient of a named component. If there was no matching component, do nothing. Note that the user will get no feedback if there was no coefficient set. Only the first occurrence of a name in the component list will be changed.

## setFirstMolecule()

void BALL::ScoringFunction::setFirstMolecule | ( | AtomContainer & | molecule1 | ) |

## setFlexibleResidues()

void BALL::ScoringFunction::setFlexibleResidues | ( | const std::set< Residue * > & | flexible_residues | ) |

## setIntercept()

void BALL::ScoringFunction::setIntercept | ( | double | intercept | ) |

## setLigand()

void BALL::ScoringFunction::setLigand | ( | AtomContainer & | ligand | ) |

Set the ligand of the complex (which is just the same as molecule2_).

## setMaximumNumberOfErrors()

void BALL::ScoringFunction::setMaximumNumberOfErrors | ( | Size | nr | ) |

## setName()

void BALL::ScoringFunction::setName | ( | String | name | ) |

protected

Set the name of this ScoringFunction

## setNormalizationParameters()

void BALL::ScoringFunction::setNormalizationParameters | ( | double | stddev,
|  | double | mean )

Set mean and standard deviation of the experimentally determined binding free energy of the used training data set.

## setReceptor()

void BALL::ScoringFunction::setReceptor | ( | AtomContainer & | receptor | ) |

Set the receptor of the complex (which is just the same as molecule1_).

## setSecondMolecule()

void BALL::ScoringFunction::setSecondMolecule | ( | AtomContainer & | molecule2 | ) |

## setup() [1/3]

bool BALL::ScoringFunction::setup | ( |  | ) |

## setup() [2/3]

bool BALL::ScoringFunction::setup | ( | AtomContainer & | receptor,
|  | AtomContainer & | ligand )

## setup() [3/3]

bool BALL::ScoringFunction::setup | ( | AtomContainer & | receptor,
|  | AtomContainer & | ligand,
|  | const Options & | options )

## setupFlexibleResidues_()

void BALL::ScoringFunction::setupFlexibleResidues_ | ( |  | ) |

protected

## setupReferenceLigand()

virtual void BALL::ScoringFunction::setupReferenceLigand | ( |  | ) |

protected virtual

Use the current ligand as reference ligand. Thus, the average number of neighboring target atoms per reference ligand atom is calculated and can later be compared to the value for a ligand candidate, so that its depth of burial is thereby estimated.

Reimplemented in BALL::GridBasedScoring.

## storeInteractionsEnabled()

bool BALL::ScoringFunction::storeInteractionsEnabled | ( |  | ) |

Tells whether interactions calculated by this ScoringFunction should be saved to each ligand atom a in a->interactions. By default storing of interactions is disabled for new ScoringFunctions.

## unsetTrainingParameters()

void BALL::ScoringFunction::unsetTrainingParameters | ( |  | ) |

Sets the coefficients of all ScoringComponents to 1 and unsets all transformations. This is necessay if obtained scores are to be used for an optimization via regression.

## update()

virtual void BALL::ScoringFunction::update | ( |  | ) |

virtual

Update all nonbonded pair-lists.

Reimplemented in BALL::DiffGridBasedScoring.

## updateComponent()

void BALL::ScoringFunction::updateComponent | ( | int | id,
|  | AtomPairList * | )

protected

## updateScore()

virtual double BALL::ScoringFunction::updateScore | ( |  | ) |

virtual

Calculates the score for the current ligand pose.

Reimplemented in BALL::DiffGridBasedScoring.

## valueToString()

String BALL::ScoringFunction::valueToString | ( | double | value | ) |

## Friends And Related Symbol Documentation

## PharmacophoreConstraint

friend class PharmacophoreConstraint

friend

Definition at line 31 of file scoringFunction.h.

## SideChainOptimizer

friend class SideChainOptimizer

friend

Definition at line 32 of file scoringFunction.h.

## Member Data Documentation

## all_ligand_nonbonded_

AtomPairVector* BALL::ScoringFunction::all_ligand_nonbonded_ {nullptr}

protected

All nonbonded pairs of the current ligand. Calculated without cutoff by createAllLigandNonBondedPairs().

Definition at line 770 of file scoringFunction.h.

## all_residues_hashgrid_

HashGrid3<Atom*>* BALL::ScoringFunction::all_residues_hashgrid_ {nullptr}

protected

Definition at line 669 of file scoringFunction.h.

## allowed_intermolecular_overlap_

double BALL::ScoringFunction::allowed_intermolecular_overlap_ {0.0}

protected

Allowed overlap in Angstroem for two atoms of two different molecules (used since even in many crystal structures, some atoms overlap minimally).

Definition at line 735 of file scoringFunction.h.

## allowed_intramolecular_overlap_

double BALL::ScoringFunction::allowed_intramolecular_overlap_ {0.0}

protected

Allowed overlap in Angstroem for two atoms of the same molecule (used since even in many crystal structures, some atoms overlap minimally).

Definition at line 741 of file scoringFunction.h.

## atoms_to_fragments_

std::map<Atom*, int> BALL::ScoringFunction::atoms_to_fragments_ {}

protected

Maps each ligand atom to its StaticLigandFragments (if StaticLigandFragments have been calculated).

Definition at line 681 of file scoringFunction.h.

## base_function_

ScoringBaseFunction* BALL::ScoringFunction::base_function_ {nullptr}

protected

The base funcion for scoring simple terms

Definition at line 626 of file scoringFunction.h.

## burial_depth_scale_

int BALL::ScoringFunction::burial_depth_scale_ {0}

protected

Definition at line 787 of file scoringFunction.h.

## conformation_scale_

double BALL::ScoringFunction::conformation_scale_ {0.0}

protected

Allows scaling down the contribution of the conformational energy of the ligand to the overall score.

Definition at line 775 of file scoringFunction.h.

## constraints

list<Constraint*> BALL::ScoringFunction::constraints {}

List holding all ReferenceAreas of the ScoringFunction.
ReferenceAreas can be added/deleted/modified directly by the user and will be used during all future calls of updateScore().

Definition at line 460 of file scoringFunction.h.

## exp_energy_mean_

double BALL::ScoringFunction::exp_energy_mean_ {0.0}

protected

Mean of the experimentally determined binding free energy of the used training data set.

Definition at line 797 of file scoringFunction.h.

## exp_energy_stddev_

double BALL::ScoringFunction::exp_energy_stddev_ {0.0}

protected

Standard deviation of the experimentally determined binding free energy of the used training data set.

Definition at line 792 of file scoringFunction.h.

## flexible_residues_

std::set<Residue*> BALL::ScoringFunction::flexible_residues_ {}

protected

Definition at line 799 of file scoringFunction.h.

## flexible_residues_hashgrid_

HashGrid3<Atom*>* BALL::ScoringFunction::flexible_residues_hashgrid_ {nullptr}

protected

Definition at line 671 of file scoringFunction.h.

## flexres_org_positions_

list<list<Vector3> > BALL::ScoringFunction::flexres_org_positions_ {}

protected

Original positions of all atoms of all flexible residues, i.e. as they appear in the input receptor object.

Definition at line 821 of file scoringFunction.h.

## hashgrid_

HashGrid3<Atom*>* BALL::ScoringFunction::hashgrid_ {nullptr}

protected

HashGrid used to find potential interaction partners for a ligand atom.

Definition at line 667 of file scoringFunction.h.

## hashgrid_search_radius_

int BALL::ScoringFunction::hashgrid_search_radius_ {0}

protected

Number of boxes around a ligand atom that are to be searched.

Definition at line 704 of file scoringFunction.h.

## ignore_h_clashes_

bool BALL::ScoringFunction::ignore_h_clashes_ {false}

protected

Determines whether an overlap between two Hydrogen atoms should be considered a sterical clash.

Definition at line 719 of file scoringFunction.h.

## intercept_

double BALL::ScoringFunction::intercept_ {0.0}

protected

The intercept necessary for calculating the score

Definition at line 621 of file scoringFunction.h.

## ligand_

AtomContainer* BALL::ScoringFunction::ligand_ {nullptr}

protected

Ligand to dock

Definition at line 611 of file scoringFunction.h.

## ligand_atoms_

int BALL::ScoringFunction::ligand_atoms_ {0}

protected

Number of atoms of the current ligand candidate. Value is set by each call of calculateGeometricalCenter()

Definition at line 657 of file scoringFunction.h.

## ligand_center_

Vector3 BALL::ScoringFunction::ligand_center_ {}

protected

Geometrical center of the current ligand

Definition at line 662 of file scoringFunction.h.

## ligand_intramol_overlaps_

int BALL::ScoringFunction::ligand_intramol_overlaps_ {0}

protected

Number of overlapping ligand atom pairs as determined by the last call of update().

Definition at line 729 of file scoringFunction.h.

## ligand_radius_

double BALL::ScoringFunction::ligand_radius_ {0.0}

protected

Radius of the current ligand, i.e. the maximal distance from its geometrical center

Definition at line 651 of file scoringFunction.h.

## max_number_of_errors_

Size BALL::ScoringFunction::max_number_of_errors_ {0}

protected

Max number of unassigned atoms

Definition at line 641 of file scoringFunction.h.

## misplaced_ligand_atoms_

int BALL::ScoringFunction::misplaced_ligand_atoms_ {0}

protected

Number of ligand atoms that were found to be lying outside of hash_grid_, as determined by the last call of createNonBondedPairList().

Definition at line 699 of file scoringFunction.h.

## name_

String BALL::ScoringFunction::name_ {""}

protected

Name of the scoring function

Definition at line 596 of file scoringFunction.h.

## neighbor_cutoff_2_

double BALL::ScoringFunction::neighbor_cutoff_2_ {0.0}

protected

Number of target atoms within this squared distance of ligand atoms are used to approximate the depth of burial of the ligand.

Definition at line 747 of file scoringFunction.h.

## neighboring_target_atoms_

int BALL::ScoringFunction::neighboring_target_atoms_ {0}

protected

Average number of target atoms within a distance of 'neighbor_cutoff' Angstroem of a ligand atom.
the value is calculated during each call of createNonBondedPairList().

Definition at line 693 of file scoringFunction.h.

## nonbonded_cutoff_

double BALL::ScoringFunction::nonbonded_cutoff_ {0.0}

protected

Cutoff value for nonbonded energy.

Definition at line 709 of file scoringFunction.h.

## nonbonded_cutoff_2_

double BALL::ScoringFunction::nonbonded_cutoff_2_ {0.0}

protected

Squared cutoff value for nonbonded energy.

Definition at line 714 of file scoringFunction.h.

## number_of_errors_

Size BALL::ScoringFunction::number_of_errors_ {0}

protected

Actual number of counted errors

Definition at line 646 of file scoringFunction.h.

## options_

Options BALL::ScoringFunction::options_ {}

protected

Scoring function options

Definition at line 601 of file scoringFunction.h.

## overlaps_

int BALL::ScoringFunction::overlaps_ {0}

protected

Number of overlapping receptor-ligand atom pairs as determined by the last call of update().

Definition at line 724 of file scoringFunction.h.

## receptor_

AtomContainer* BALL::ScoringFunction::receptor_ {nullptr}

protected

Receptor to dock in

Definition at line 606 of file scoringFunction.h.

## reference_neighbors_

int BALL::ScoringFunction::reference_neighbors_ {0}

protected

Average number of interactions per atom of a reference ligand within a small radius. This is used to estimate the depth of burial of the ligand (candidate).

Definition at line 687 of file scoringFunction.h.

## resolution_

double BALL::ScoringFunction::resolution_ {0.0}

protected

Resolution that was specified by use of the Options object in the constructor.

Definition at line 676 of file scoringFunction.h.

## result_

Result BALL::ScoringFunction::result_ {}

protected

Saves the final and all intermediate results of the last call of updateScore().

Definition at line 804 of file scoringFunction.h.

## rotatable_ligand_bonds_

vector<Bond*> BALL::ScoringFunction::rotatable_ligand_bonds_ {}

protected

Rotatable bonds of the current ligand molecule. They are calculated by the function createStaticLigandFragments().

Definition at line 815 of file scoringFunction.h.

## score_

double BALL::ScoringFunction::score_ {0.0}

protected

Overall score of the scoring function

Definition at line 616 of file scoringFunction.h.

## scoring_components_

vector<ScoringComponent*> BALL::ScoringFunction::scoring_components_ {}

protected

The scoring components used by a particular scoring function (e.g. HBonds, VDW, etc.)

Definition at line 631 of file scoringFunction.h.

## static_ligand_energy_

double BALL::ScoringFunction::static_ligand_energy_ {0.0}

protected

Energy of the StaticLigandFragments. Is calculated once for each ligand candidate by createStaticLigandFragments().

Definition at line 809 of file scoringFunction.h.

## static_ligand_fragments_

vector<StaticLigandFragment*> BALL::ScoringFunction::static_ligand_fragments_ {}

protected

contains the static fragments of the current ligand candidate.
The conformation of each ligand is not changed during docking; only the position of fragments in relation to each other is modified.
Thus, if static_ligand_fragments_ is not empty, createNonBondedPairList() will automatically search only for inter-fragment atom-pairs and ligand-receptor pairs, but not for intra-fragment pairs.

Definition at line 756 of file scoringFunction.h.

## static_residues_hashgrid_

HashGrid3<Atom*>* BALL::ScoringFunction::static_residues_hashgrid_ {nullptr}

protected

Definition at line 670 of file scoringFunction.h.

## store_interactions_

bool BALL::ScoringFunction::store_interactions_ {false}

protected

Determines whether interactions calculated by this ScoringFunction should be saved to each ligand atom a in a->interactions.
By default this is disabled for new ScoringFunctions.

Definition at line 763 of file scoringFunction.h.

## store_interactions_phC_only_

bool BALL::ScoringFunction::store_interactions_phC_only_ {false}

protected

Definition at line 765 of file scoringFunction.h.

## SUBCATEGORY_NAME

const char* BALL::ScoringFunction::SUBCATEGORY_NAME

static

Definition at line 36 of file scoringFunction.h.

## unassigned_atoms_

HashSet<const Atom*> BALL::ScoringFunction::unassigned_atoms_ {}

protected

Atoms, for which the setup of the force field fails

Definition at line 636 of file scoringFunction.h.

## use_all_lig_nonb_

bool BALL::ScoringFunction::use_all_lig_nonb_ {false}

protected

see Default::ALL_LIG_NONB_PAIRS

Definition at line 780 of file scoringFunction.h.

## use_static_lig_fragments_

bool BALL::ScoringFunction::use_static_lig_fragments_ {false}

protected

see Default::USE_STATIC_LIG_FRAGMENTS

Definition at line 785 of file scoringFunction.h.