PTools.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.
*/

#ifndef PTOOLS_H
#define PTOOLS_H


#include "PBasic.h"
#include "PExtension.h"
#include "PNumRoutines.h"
#include <gsl/gsl_sf_bessel.h>


typedef Real(*ConformationDistFn)(const PLightChain*, const PLightChain*);

struct NullSpaceRet{
        double *Sval;
        double **Svec;
        int *ns;
        int n_ns;
};

class PCluster;
//@package Inverse Kinematics
class PTools {
  public:

    static void GetGoals(PAtom *anchorPrior, PAtom *anchorEnd, PAtom *effectorPrior, PAtom *effectorEnd,
                          Real len, Real angle1, Real angle2, Vector3 &goalPrior, Vector3 &goalEnd);

    static void GetGoals(PProtein *protein, ProteinSide side, Vector3 &goalPrior, Vector3 &goalEnd);

    static ProteinSide GetGoals(PProtein *protein, Vector3 &goalPrior, Vector3 &goalEnd);

    static PProtein *CreateSlimProtein(PProtein *protein);
    static PProtein *CreateSlimProtein(PProtein *protein, int startRes, int endRes);

    static Real EffectorAnchorDist(PProtein *loop, ProteinSide side);

    static PChain *LowestCommonChain(PChain *c1, PChain *c2);

    static list<PCluster> GetClusters(const PConformationSpace &space,
                                      ConformationDistFn distFn,
                                      Real threshold);

    static int getBackboneAtomIndex(int resIndex, const string &atomID);

    //static bool ApplyRotamer(PResidue *res);

    static void ComputeJacobian(PProtein *loop, vector<int> ind, double **Jac, Vector3 p,bool forward);

    static void ComputeJacobian(PProtein *loop, vector<int> ind, double **Jac, bool forward);
    
    static void ComputeJacobian(PProtein *loop, double **Jac);

    static void ComputePseudoInverse(double **A, int m, int n, double **Ainv);
    static void ComputeNullSpace(double **Jac, int dim, bool SixDimensional, NullSpaceRet* Ret);
    static void ProjectOnNullSpace(PProtein *loop, vector<int> ind, bool forward, double ToProject[], double AfterProject[]);
    static vector<vector<CDof> > GetBBDofs(vector<PProtein *> loops);

    static double RMSDBackbone(PProtein *protein0, PProtein *protein1, int loopstart, int loopend);

    static double RMSDAllAtom(PProtein *protein0, PProtein *protein1, int loopstart, int loopend);

    static bool CopyBackbone(PProtein *lpS, PProtein *lpD, int startS, int startD, int numRes);
    static bool CopyBackbone(PProtein *lpS, PProtein *lpD);
    static void RandomNullSpacePerturb(PProtein *lp, double pert_mag);
    static void RandomNullSpacePerturb(PProtein *lp, vector<vector<CDof> > Dofs, double pert_mag);
    static IKSolution CloseAlmostClosedLoop(PProtein *lp, Vector3 endPriorGoal,Vector3 endGoal, Vector3 endNextGoal);
    static int gsl_test();
  private:

};
//@package Conformation Analysis
class PCluster {
 public:

  PCluster();

  PCluster(const PCluster &other);

  ~PCluster();

  void AddConformation(PLightChain *toAdd);

  void MergeWithCluster(PCluster &other);

  PLightChain *GetRepresentativeConformation() const;

  int size() const { return m_confs->size(); }

  bool empty() const { return m_confs->empty(); }

  list<PLightChain *> getConformations() const {
    return *m_confs;
  }


 private:
  list<PLightChain *> *m_confs;
  
};

#endif

---