PExtension.h

Go to the documentation of this file.

/*
    LoopTK: Protein Loop Kinematic Toolkit
    Copyright (C) 2007 Stanford University

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

/*
 * PExtension defines a variety of auxiliary
 * classes that are not considered part of the
 * "core" LoopTK class hierarchy. These include
 * file I/O classes, initialization classes,
 * test classes, and so forth.
 */

#ifndef PEXTENSION_H
#define PEXTENSION_H

#include "PBasic.h"
#include "PIKAlgorithms.h"
#include "PConstants.h"
// @package Conformation Analysis

#include <libxml/parser.h>
#include <libxml/tree.h>

typedef list<PLightChain *> PLightChainList;

class PConformationSpace: public PLightChainList
{
 public:

  PConformationSpace(pair<PLightChain *,PLightChain *> staticPortions);
  ~PConformationSpace();
  
  pair<PLightChain *, PLightChain *> getStaticPortions() { return m_staticPortions; }

 private:
  pair<PLightChain *,PLightChain *> m_staticPortions;

};


/*
 * A csConfLine (conformation line) defines a new position for one
 * particular atom in one particular loop residue.
 */

#define         csConfLine              pair<pair<int, string>, Vector3>

enum WarningIndicator {
  SUPPRESS_WARNINGS,
  ENABLE_WARNINGS
};
// @package Main Infrastructure
class LoopTK {
 public:

  static void Initialize(WarningIndicator ind);

  static void SuppressWarnings();

  static void EnableWarnings();

  static void DisplayWarning(const string &warning);
 private:
  static bool m_warningsEnabled;
};

//@package Resource Management
class PInit {
  friend class LoopTK;

  public:
    static string GetName(xmlNodePtr node);
    static string GetAttribute(xmlNodePtr node, const string &attr);

  private:
    static void InitializeResources();

    static HASH_MAP_STRPAIR_EX(vector<PBlockBondShell>) blockBonds;
    static HASH_MAP_STRPAIR_EX(HASH_MAP_STRPAIR_EX(Vector3)) relPos;

    static void setupBlockShells();
    static void setupBlockConnections();
    static void setupResidueShells();

    static void setupAtomShells();
    static void setupChiIndices();
    static void setupEpsilonVals();
    static void setupIDMaps();
    static void setupRotamers();
};
//@package Input-Output
class PDBIO {
  friend class CS2IO;   /* To access readFromLines(). */

  public:

    struct pdbAtomLine {
      string atomName, resName, elem;
      char altLoc, insCode, chainID;
      int atomNum, resNum;
      string occupancy, tempFactor;
      Vector3 pos;
    };

    static PProtein* readFromFile(const string &fileName);

    static void writeToFile(PChain *chain, const string &fileName, const string &prefix = "");

    static bool isCyclicPDB(const string &fileName);

    static vector<string> getAllAtomLines(const vector<string> &pdbLines);

    static pdbAtomLine parseAtomLine(const string &line);

  private:

    /* Helper functions for readFromFile(). */

    static PProtein* readFromLines(const vector<string> &pdbLines);
    static PProtein* readFromMap(const hash_map<int, vector<pdbAtomLine> > &atomMap, 
                                 const set<int> &allResNums);
    static void updateProtein(PProtein* &protein, const string &resName,
                                PResidueSpec &spec, int resNum);

    static void trimHeadAndTail(vector<int> &resIndices, const hash_map<int,
                                vector<pdbAtomLine> > &atomMap);
    static PResidueSpec getSpec(const vector<pdbAtomLine> &atomLines);
    static bool definesBackbone(PResidueSpec &spec);

    /* Helper functions for writeToFile() that do some error checking. */

    static void addAtomNum(string &pdbOutLine, int atomNum, string::size_type prefixLen);
    static void addAtomName(string &pdbOutLine, const string &atomName, string::size_type prefixLen);
    static void addResName(string &pdbOutLine, const string &resName, string::size_type prefixLen);
    static void addChainID(string &pdbOutLine, char chainID, string::size_type prefixLen);
    static void addResNum(string &pdbOutLine, int resNum, string::size_type prefixLen);
    static void addInsertionCode(string &pdbOutLine, const string &insCode, string::size_type prefixLen);
    static void addAtomPos(string &pdbOutLine, const Vector3 &atomPos, string::size_type prefixLen);
    static void addAuxData(string &pdbOutLine, Real occupancy, Real tempFactor,
                                const string &segmentID, string::size_type prefixLen);
    static void addElemName(string &pdbOutLine, const string &elemName, string::size_type prefixLen);

};

//@package Math
class PMath {
  public:

   static Real AngleBetweenPlanes(const Vector3 &p1, const Vector3 &p2,
                                  const Vector3 &p3, const Vector3 &p4);

    static Real getAngle(const Vector3 &v1, const Vector3 &v2);

    static Vector3 ComputePos(const Vector3 &prev, const Vector3 &cur, Real angle, Real bondLength);

    static bool sphereIntersectsCube(const Vector3 &sphereCenter, Real sphereRadius,
                                     const Vector3 &cubeVertex1, const Vector3 &cubeVertex2);

    static Vector3 ArbitraryNonParallel(const Vector3 &v);

    static void normalize(vector<double> &v);

    //finds transform that moves s1 to e1 and s2 to e2
    static Matrix4 Find2PtTransform(Vector3 s1, Vector3 s2, Vector3 e1, Vector3 e2);

    static Matrix3 FindRotationMatrix(const Vector3 &axis, Real angle);

    static Vector3 LocalToGlobalCoord(const vector<Vector3> definedRelativeCoordinates, const vector<Vector3> definedGlobalCoordinates);
    static void ConvertToQuaternion(double** input, Vector4* output, vector<int> sign);
    static void InterpolateQuaternion(Vector4 qi, Vector4 qf, Vector4* qu, double u);
    static void DeltaQuaterToDeltaVel(Vector4 qi, Vector4 qf, Vector3* delatV);
   
     static int signum(double a);
  
    static double TorsionAngle(Vector3 u,Vector3 v,Vector3 w);
};

class Angle {

  public:

    Angle(AngleType type, Real value);

    Real getDegrees();

    Real getRadians();

  private:

    AngleType m_type;   /* The angle type (radians or degrees). */
    Real m_value;       /* The angle value in m_type units.     */

};
//@package Input-Output
class CS2IO {

  public:

    static PProtein* readConformation(const string &cs2File, int confNum);

    static PLightChain *readConformationLoopOnly(const string &cs2File, int confNum);
    
    static PConformationSpace *readConformationSpace(const string &cs2File);

    static pair<PLightChain *, PLightChain *> getNonLoopChains(const string &cs2File);

    static void appendConformation(const string &cs2File, PProtein *loop);

    static void writeToFile(const string &cs2File, PProtein *loop);

    static int getNumConformations(const string &cs2File);

    static void createPDBDirectory(const string &cs2File,const string &directoryName);


  private:

    /* Versions of the public functions that read from constituent components
     * of CS2 file. */
    static PLightChain *readConformationLoopOnly(const vector<string> &atomLines,
                                                 const vector<string> &loopLines,
                                                 const vector<string> &confLines,
                                                 const string &fileName);
    static pair<PLightChain *, PLightChain *> getNonLoopChains(const vector<string> &atomLines,
                                                               const vector<string> &loopLines,
                                                                const string &fileName);

    /* Grabs the PDB atom lines, "loop" line and (optionally) conformation lines in cs2File. */
    static void parseFile(const string &cs2File, vector<string> &atomLines, vector<string> &loopLines);
    static void parseFile(const string &cs2File, vector<string> &atomLines, vector<string> &loopLines,
          vector<vector<string> > &allConfLines);
    static void parseFile(const string &cs2File, int confNum, vector<string> &atomLines, vector<string> &loopLines,
          vector<string> &confLines);

    /* Helpers for parseFile. */
    static vector<string> extractAtomLines(const vector<string> &cs2Lines, const string &fileName);
    static vector<string> extractLoopLines(const vector<string> &cs2Lines, const string &fileName);
    static vector<vector<string> > extractConfLines(const vector<string> &cs2Lines, const string &fileName);

    /* Parses a "cn" line, using sanityCheck to make sure residue indices are valid. */
    static csConfLine parseConfLine(const string &cs2File, const string &cs2Line,
        const pair<int, int> &sanityCheck);

    /* Counts the number of conformations in the specified CS2 file. */
    static int countConformations(const string &cs2File);

    /* Writes loop to the specified file as the confNum'th conformation,
     * using the specified start and end residue indices into the top level. */
    static void outputHelper(const string &cs2File, PProtein *loop, int confNum,
           int startIndex, int endIndex);

    /* Parses a "loop" line from the specified file into its constituent pair of ints. */
    static pair<int, int> parseLoopLine(const string &cs2File, const string &loopLine);

    /* Applies the specified conformation to loop, subtracting offset from start index. */
    static void applyConfLine(PProtein* &loop, const csConfLine &conf, int offset = 0);
};

typedef Real(*EnergyCalcFn)(const PAtom *, const PAtom *);

//@package Math
class PEnergy {

  public:

        static const Real DEFAULT_THRESHOLD = 10;

        static Real vanDerWaalsEnergy(const PAtom *a1, const PAtom *a2);

        static Real energyOfChain(PChain *chain, EnergyCalcFn energyFn = vanDerWaalsEnergy, Real threshold = DEFAULT_THRESHOLD);

        static Real collisionEnergy(const PAtom *a1, const PAtom *a2);


  private:

};
 //@package Optimization
class PMoveAtom {

  public:
        static vector<IKSolutions> MoveAtom(vector<PProtein*> loops, vector<vector<CDof> > Dofs, vector<int> AtomToMove, vector<Vector3> MovementDirn);
        static IKSolutions MoveAtom(PProtein *loop, int AtomToMove, Vector3 MovementDirn);

  private:

};

#endif

---