PResidue.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 __P_RESIDUE_H
#define __P_RESIDUE_H

#include "PEnums.h"
#include "PResidueShell.h"
#include "PResidueSpec.h"

class PResidue {
 public:
  friend class PChain;
  friend struct DOFCacher;

  PResidue(PChain *loop, const string &shellName);

  PResidue(PChain *loop, const string &shellName, PResidueSpec &spec); 

  PResidue(PChain *loop, const string &shellName, PResidue *toConnect);

  PResidue(PChain *loop, const string &shellName, PResidueSpec &spec, PResidue *toConnect);

  ~PResidue();

  PResidue *NextResidue() const { return m_nextRes; }

  PResidue *PreviousResidue() const { return m_prevRes; }

  PBond *getDOF(const string &blockType, const string &atomId1, const string &atomId2);


  const ID_To_DOF_Map *getDOFsForBlock(const string &blockType);

  void RandomizeDOFs(const string &blockType, PChain *rootChain);
  void RandomizeDOFs(const string &blockType);

  void DetachBlocks(const string &blockType, const string &blockToDetachFrom);
  void ReattachBlocks(const string &blockType);
  void ReattachAllBlocks();

  PBond *getBond(const string &id1, const string &id2);

  PChain* getChain() const;

  string getResourceName() const { return m_shell->getName(); }

   string getName() const { return m_customName; }

   void setName(string name) { m_customName = name; }

  PBlock *getHeadBlock() { return m_blocks[m_shell->getHeadId()]; }

  PBlock *getTailBlock() { return m_blocks[m_shell->getTailId()]; }
  
  vector<PAtom *> *getAtoms() { return &m_atomCache; }

  HASH_MAP_STR(PAtom *) *getAtomMap() { return &m_atomMap; }

  PAtom *getAtom(const string &id) { 
        if(m_atomMap.find(id)==m_atomMap.end()) return NULL;
        else
                return m_atomMap[id]; 
  }

  Vector3 getAtomPosition(const string &id) { return getAtom(id)->getPos(); }

  bool InStaticCollision() const;

  bool InSelfCollision() const;

  bool InAnyCollision() const;
  
  pair<PAtom *, PAtom *> FindStaticCollision() const;

  pair<PAtom *, PAtom *> FindSelfCollision() const;

  pair<PAtom *, PAtom *> FindAnyCollision() const;

  AtomCollisions* getAllCollidingStatic() const;

  AtomCollisions* getAllCollidingSelf() const;

  AtomCollisions* getAllCollidingEither() const;

  const PSpaceManager* getSpaceManager() const;

  PResidueSpec getSpec();

  void setPositions(const PAtomPositionsSpec &spec);

  int getPdbId() const { return m_pdb_id; }


  void inactivate();

  void activate();


 private:

  void EstablishLink(PResidue *prior);
  //these two functions are called by PChain:
  void SetChain(PChain *loop) { assert(loop != NULL); m_loop = loop; }
  //caches atoms, block types
  void finalize();
  void ChangeBlockState(const string &blockType, bool status);

  //for use by PChain: //should be called after finalize is called
  void CacheDOF(DOF_Cache &DOFcache);
  void CacheAtoms(Atom_Cache &AtomCache);
  void DestroyBonds();

  void ConstructAroundHead(PChain *loop);
  void BuildWithPositions(PChain *loop, const PResidueSpec &spec);
  void AddAuxInfo(PResidueSpec &spec);

  // Returns true iff all of shell's atoms are defined in spec.
  bool IsFullyDefined(const string &shellName, const PResidueSpec &spec);


  // collision detection helper methods
  bool InCollision(CollisionType type) const;
  pair<PAtom *, PAtom *> FindCollision(CollisionType type) const;
  AtomCollisions* getAllColliding(CollisionType type) const;

  //for use by DOF_Cacher
  void CacheSingleDOF(const string &blockType,PBond *bond);

  PResidueShell *m_shell;
  HASH_MAP_STR(PBlock *) m_blocks;
  PChain *m_loop;
  string m_customName;

  // Index of this residue in a PDB file
  int m_pdb_id;
  
  // Atoms in this residue
  HASH_MAP_STR(PAtom *) m_atomMap;

  // Next and previous residues in the chain
  PResidue *m_nextRes, *m_prevRes;

  //caches:
  //turning blocks on and off should update this cache (or should it?)
  vector<PAtom *> m_atomCache;
  typedef HASH_MAP_STR(vector<PBlock *>) BlockTypeCache;
  BlockTypeCache m_blockTypeCache; 
  HASH_MAP_STR(HASH_MAP_STRPAIR_OR(PBond *)) m_dofs;
  
};

#endif  // __P_RESIDUE_H

---