Library GAMB

[ Keywords | Classes | Data | Functions ]

Quick Index

AUTHORS

CHANGES LOG

CODE

COMPILATION

Classes

AminoAcid

Container that stores Atom's of amino acid. In addition the class provides a general information about amino acid residues.

AminoAcidScore

This class serves for a score calculation of sequence of amino acid pairs. The score can be based on the PAM250 or BLOSUM62 matrix or any other user defined score matrix.

Atom

This is a general class to hold an atom as it appears in a PDB file.

BipartiteMatcher

Implements bipartite matching using LEDA. Given a model, a target, edges of possible matches, and a transformation, it will find the best bipartite match. NOTE: HausdorffExtension proves faster and better then BipartiteMatcher.

ClusterEngine

Class template defines a framework for performing clustering operation. The class is receives a list of data elements and clusters them using the algorithms in the ClusterList class template.

ClusterList

Class template defines a framework for performing clustering operation. Clustering is performed by adding a list of potentially neighboring data elements and then calling the cluster method.

DebugStream

Defines a class for printing logs and debug information. User may determine the extent of the debugging information actually printed by setting the debug level.

GeomHash

The template defines a geometric hash table class. The class is declared using a key type with which the data type instances are inserted and accessed. The geometric hash table may be instantiated using any dimension and grid-size.

HashIndex

Defines a simple multi-dimensional index for the gemotric hash table defined in class GeomHash.

HashInterface

The class can build Interface object efficiently by using Geometric Hashing for the particles of the first molecule. template< class MoleculeT>

HashIterator

Template defines an STL-like iterator over geometric hash table query results. (See GeomHash). The iterator is used within the HashResult container.

HashLink

Template serves as the main engine of the geometric hash table. Classes defined are used by GeomHash to build, traverse and query a multi-dimensional hash-table.

HashResult

Template defines an STL-like container class used to hold geometric hash table query results. (See GeomHash). The results are iterated through using the HashIterator STL-like iterator class.

HausdorffExtension

proves faster and better then BipartiteMatcher. Uses Geometric Hashing. usage: call to static func Extend: HausdorffExtension::Extend(threshExtend, rigidTrans(), molModel, molTarget,outMatch);

Helix

This class defines the information on the secondary structure alpha helix.

HelixPDB

This class defines a set of tools to be used when trying to read alpha helix secondary structure from the Protein Data Bank file format.

Interface

Defines an interface container and used to store interfaces between molecules.

Line

This class represents a 3D line by its direction and by an arbitrary point that passes through it. The equation of the line in a vector-parametric form is: p(t) = p0 + ut, where t is a real valued parameter, u is the direction of the line and p0 is an arbitrary point that passes through it.

Match

Defines a match object used to build and refine matches between Molecule type objects. Matches are build by matching pairs of Particles from each Molecule.

Matrix3

Defines a 3x3 matrix with a load of constructors, operators, and methods.

Molecule

Template defines a collection of Particles that make up a Molecule. Among others class hosts a PDB file readr and linear algebra operators.

MoleculeGrid

This class provides discrete representation of the molecule. The molecule is represented by a grid. Each voxel of the grid is marked as follows:

• Negative value for the inside of the molecule
• Zero for the surface
• Positive for outside voxels

In addition the distance function can be calculated for each voxel. The distances are zero at the surface voxels and change as the distance from the surface increases/decreases. The distance function is negative for inside molecule voxels and positive for outside voxels.

NucleicAcidAtom

Nucleotide

A container that stores all NucleicAcidAtoms of a nucleotide

NucleotideData

A container that stores additional information for the class Nucleotid

PDB

The PDB class defines a set of tools used for reading the Protein Data Bank file format, used to describe molecular structures, like proteins, drugs and Nucleic Acids

Parameters

A utility class used to manage program parameters. The class supports setting default values for parameters, reading values from a parameters file and accessing parameters values from other parts of the program.

Particle

A class meant to serve as a basis for particle types such as atoms, molecular surface points etc. This class's only property is position and operators to alter the Particle's position are supplied. Users of the class are encouraged to use the class as an inheritance base in creating their Particle types.

ParticleAttribute

This is a template base class for all the the scoring mechanisms we need on various issues of docking or matching schemes.

RMSDCluster

Template intended to provide a good quality clustering of transformations, using the distance between two transformations as the RMSD of the picture on a set of points. (the set of points is given by the user in the preProcessing stage). RMSDCluster provides two clustering algorithms - one is faster and less accurate, while the other is more thorough but is limited by the number of transformations it can handle. The decision of which algorithm to use is left to the user, who can determine with the useFastClustering method to use the faster algorithm. The user is also required to supply the hash cube size for the fast clustering. The larger the cube size the more accurate the algorithm is, but also there will be more transformations in each bin and so the algorithm will be slower. Both algorithms are iterative trying to join pairs of close transformatins using a weighted average heuristic. The difference is that the thorough algorithm calculates the entire distance matrix of all the transformations at once and then continuessly contracts the smallest edge that connects vertices that were not used in this iteration, while the faster algorithm uses a hash table and at first only clusters transformations which put the centroid of the molecule in close locations. Calculation of the distance between any two rigid transformation is O(n) in complexity, where n is the number of points, given in the pre-processing stage. template< class TransT>

ReferenceFrame

Holds rigid transformations, reference frames, axis systems using a compact Rotation3 object and a trnaslational vector.

RigidTrans3

Defines 3-dimensional rigid transformations class. Rigid transformations are comprised of a rotation followed by a translation of the vector space.

Rotation3

Defines a rotation of 3-dimensional space.

SecondStruct

This class encapsulate all the reading of the secondary structure from the PDB file and gives various methods of verification on them

Segment

This class represents a 3D line segment by two 3D points.

Sheet

This class defines a beta sheet that is constructed from beta strands

Shou

Defines a set of methods to read Shou format files. The Shou format files are created using the PDBCP program which outputs a set of critical points describing the molecular surface.

SmallArray

This class allows you to declare a small array of max const size. Not like the ordinary c array it provides boundry checking both on inserting and on requiring information from it.

SmallVector

Defines a vector template. This class template was designed as a cheap substitute to vector<> class template. The SmallVector class has a smaller executable size, takes up less memory, is simpler and should usually prove to be faster than the larger, more verbose vector<> class. template< class T, class Alloc = ShortVectorBase>

Strand

This class defines strand that is a part of the beta sheet.

StrandConnection

This class defines the connection between two strands in the same beta sheet.

StrandPDB

This class defines a set of tools to be used when trying to read beta sheet secondary structure from the Protein Data Bank file format.

Surface

Defines a collection of SurfaceParticle's that make up the surface of a molecule. The class hosts a reader that reads output out of a Shou surface file.

SurfacePoint

A descendant of the Vector3 class. Serves as a base class for surface points. Besides their positions holds geometrical information such as nornal to the surface and type of surface point (caps, pits and belts).

Timer

This is a general class to compute the user processor time on parts of the program.

Torsion

Class for torsion rotation support

TransformDistance

Class that allows to compute rmsd between two transformations in constant time

Triangle

Defines a triangle class for easy triangle handling (Includes transformation operator (|))2

UnionList

Template defines a data structure to handle union finds. The structure can be used to collect elements into unions. The unions may be represented by a different type from its elements.

Vector2

Defines a 2D vector class with operators.

Vector3

Defines a 3D vector class with operators.

WeightedAttribute

This template class that inherits the ParticleAttribute class enhance it in adding a specific weight to each attribute, and a preference that allows you to compute a scoring of several on a preferential bases.

gzstream

C++ iostream classes wrapping the zlib compression library.

Back to the top of GAMB

Data

Back to the top of GAMB

Global Functions

Back to the top of GAMB

using std::vector;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

using std::vector;

Back to the top of GAMB

typedef leda::GRAPH< unsigned int, short> BipartiteGraph;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef leda::GRAPH< unsigned int, short> BipartiteGraph;

Back to the top of GAMB

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

Back to the top of GAMB

BipartiteMatcherXhXmemberX11_2

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#endif //BIPARTITEMATCHER_H

Back to the top of GAMB

AUTHORS

Copyright: SAMBA group, Tel-Aviv Univ. Israel, 1997.

Back to the top of GAMB

CHANGES LOG

Back to the top of GAMB

CODE

The code is documented using specially formatted comments. Using a freeware package named cocoon a javadoc like html documentation was generated from the source code and may be found in the Documentation directory of the library. The cocoon package resides at mol/utils/cocoon.

The Cocoon utilities can be found at http://www.cs.umn.edu/~kotula/cocoon/cocoon.htm. One can get intructions on what kind of comments coccon expects to find and what it will do with them.

Back to the top of GAMB

COMPILATION

Currently code is compiled using the SGI STL library which was ported to GNU. This STL implementation is considered the best and may be found at /mol/lib/gstl with a Documentation directory. */

Back to the top of GAMB

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

Back to the top of GAMB

enum MSG_LEVEL ;

The different message levels

  enum MSG_LEVEL {ERROR_LEVEL = 0,
		  WARNING_LEVEL = 1,
		  INFO_LEVEL = 2,
		  DEBUG_LEVEL = 3};

Back to the top of GAMB

Logger& getInstance();

  static Logger& getInstance();

Back to the top of GAMB

Logger& errorMessage() ;

Gets a reference to the Logger and starts a new error message One should note that using this method and only then streaming the message is not thread safe.

  static Logger& errorMessage()                                             
;

Function is currently defined inline.

Back to the top of GAMB

Logger& warningMessage() ;

Gets a reference to the Logger and starts a new warning message One should note that using this method and only then streaming the message is not thread safe.

  static Logger& warningMessage()                                               
;

Function is currently defined inline.

Back to the top of GAMB

Logger& infoMessage() ;

Gets a reference to the Logger and starts a new info message One should note that using this method and only then streaming the message is not thread safe.

  static Logger& infoMessage()                                            
;

Function is currently defined inline.

Back to the top of GAMB

Logger& debugMessage() ;

Gets a reference to the Logger and starts a new debug message One should note that using this method and only then streaming the message is not thread safe.

  static Logger& debugMessage()                                             
;

Function is currently defined inline.

Back to the top of GAMB

bool isActiveLevel(MSG_LEVEL level)

Returns true if messages with the given level will be printed to the log file

  static bool isActiveLevel(MSG_LEVEL level)                                                                         

Back to the top of GAMB

MSG_LEVEL getLevel() ;

  MSG_LEVEL getLevel()                                                  
;

Function is currently defined inline.

Back to the top of GAMB

void setLevel(MSG_LEVEL msgLevel) ;

set level

  void setLevel(MSG_LEVEL msgLevel)                                       
;

Function is currently defined inline.

Back to the top of GAMB

Logger& operator()(MSG_LEVEL msgLevel);

Starts a new message and specifies its level. One should note that setting the level outside of the actual message (i.e., first calling this operator and only then streaming the message) is not thread safe.

  Logger& operator()(MSG_LEVEL msgLevel);

Back to the top of GAMB

template< class T> Logger& operator<<(const T& data);

If a message was started with a low enough message level then given data will be printed to the log file

  template< class T>
  Logger& operator<<(const T& data);

Back to the top of GAMB

template< class T> Logger& operator<<(T& data);

If a message was started with a low enough message level then given data will be printed to the log file

  template< class T>
  Logger& operator<<(T& data);

Back to the top of GAMB

Logger& operator<<(ostream& (*__pf)(ostream&));

The Logger can stream a function that accepts an ostream and returns one.

  Logger& operator<<(ostream& (*__pf)(ostream&));

Back to the top of GAMB

~Logger();

  ~Logger();

Back to the top of GAMB

void init();

  static void init();

Back to the top of GAMB

Logger* instance;

  static Logger* instance;

Back to the top of GAMB

DebugStream log;

  DebugStream log;  

Back to the top of GAMB

Logger(const string logFile, unsigned int logLevel);

  Logger(const string logFile, unsigned int logLevel);

Back to the top of GAMB

enum AtomEntryType ;

enum  AtomEntryType {UNK = 0, ATOM = 1, HETATM = 2}; 

Back to the top of GAMB

typedef hash_map< unsigned int, pair< char,short> >::iterator HashIter;

Maps a residue index to its SSE number

  typedef hash_map< unsigned int, pair< char,short> >::iterator HashIter;

Back to the top of GAMB

destroy(array, array+occ);

a question here shouldn't I destroy only occ don't seem like it but I might want to ask meir just in case

  destroy(array, array+occ);

Back to the top of GAMB

string trim_left(const string& str ) ;

Trims spaces at the left side of a string

  static inline string trim_left(const string& str )
                                                                                                                                                
;

Function is currently defined inline.

Back to the top of GAMB

string trim_right(const string& str ) ;

Trims spaces at the right side of a string

  static inline string trim_right(const string& str )
                                                                                                                                                   
;

Function is currently defined inline.

Back to the top of GAMB

string trim(const string& str ) ;

Trims spaces at both sides of a string

  static inline string trim(const string& str )
                                              
;

Function is currently defined inline.

Back to the top of GAMB

string toUpperCase(const string& s);

turns all the string to upper case

  static string toUpperCase(const string& s);

Back to the top of GAMB

char* concat(const char* const s1, const char* const s2);

return a string, which is the concatenation of s2 to s1

  static char* concat(const char* const s1,
                      const char* const s2);

Back to the top of GAMB

void reverse(char *s);

reverse the order of the given chars

  static void reverse(char *s);

Back to the top of GAMB

void eraseLine(ostream& i_s,int size );

Erases chars from a stream

  static void eraseLine(ostream& i_s,int size=80);

Back to the top of GAMB

void stringSplit(const string str, string delim, vector< string>& results);

Splits a given line by the given delimiter

  static void stringSplit(const string str, string delim, vector< string>&  results);

Back to the top of GAMB

template< class StreamT> string getLine(StreamT& istr);

Reads a line from an input stream (till EOF or \n)

  template< class StreamT>
  static string getLine(StreamT& istr);

Back to the top of GAMB

bool isBlankLine(const char *const line);

Return true if the line is empty or spaces and tabs only

  static bool isBlankLine(const char *const line);

Back to the top of GAMB

string l2str(long l);

converts long into string

  static string l2str(long l);

Back to the top of GAMB

string d2str(double d);

converts double into string

  static string d2str(double d);

Back to the top of GAMB

template<class T> string d2str(const T d) ;

Double/Float into string

template<class T>
inline string d2str(const T d)                                                                          
;

Function is currently defined inline.

Back to the top of GAMB

string l2str(const long l) ;

Long into string

inline string l2str(const long l)                                                                        
;

Function is currently defined inline.

Back to the top of GAMB

string i2str(const int l) ;

Int into string

inline string i2str(const int l)                                                                       
;

Function is currently defined inline.

Back to the top of GAMB

template<class T> T sqr(const T x) ;

Template function returns x squared.

template<class T>
inline T sqr(const T x)
                 
;

Function is currently defined inline.

Back to the top of GAMB

template<class T> T tabs(const T& x) ;

Template function returns absolute value of referenced x.

template<class T>
inline T tabs(const T& x)                         ;

Function is currently defined inline.

Back to the top of GAMB

template<class T, class S> T sign(const T a, const S b) ;

Template function returns a with b's sign

template<class T, class S>
inline T sign(const T a, const S b)
                                 ;

Function is currently defined inline.

Back to the top of GAMB

template<class T> T min2(const T x, const T y) ;

Template function returns minimum of two numbers

template<class T>
inline T min2(const T x, const T y)                       ;

Function is currently defined inline.

Back to the top of GAMB

template<class T> T max2(const T x, const T y) ;

Template function returns maximum of two numbers

template<class T>
inline T max2(const T x, const T y)                       ;

Function is currently defined inline.

Back to the top of GAMB

template<class T> T max3(const T x, const T y, const T z) ;

Template function returning maximum of three numbers

template<class T>
inline T max3(const T x, const T y, const T z)                                         ;

Function is currently defined inline.

Back to the top of GAMB

template<class T> T min3(const T x, const T y, const T z) ;

Template function returnin minimun of three numbers

template<class T>
inline T min3(const T x, const T y, const T z)
                                       ;

Function is currently defined inline.

Back to the top of GAMB

sorting x y and z from smalles to biggest such that x<=y<=z

/* template<class T>
inline void sort3(T& x, T& y, T& z)
{
    T tmp;
    if (x > y) {
        tmp = x;
        x = y;
        y = tmp;
    }
    else if (x > z) {
        tmp = x;
        x = z;
        z = tmp;
    }
    else if (y > z) {
        tmp = y;
        y = z;
        z = tmp;
    }
}

Function is currently defined inline.

Back to the top of GAMB