PAtom.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_ATOM_H
#define __P_ATOM_H

#include <string>
using std::string;

#include <math3d/primitives.h>
#include <GLdraw/GLMaterial.h>
using namespace Math3D;

#include "PAtomShell.h"
#include "PFunctors.h"
#include "PHashing.h"

class PBlock;
class PChain;
class PGrid;
class PSpaceManager;
class PResidue;

class PAtom {
  public:
    friend class PBond;         // so it can add itself to the m_bonds array
    friend class PResidue;      // so that it can call CacheDOF
    friend class PBlock;                // so it can remove atoms on deactivation

    PAtom(PBlock * block, const string &name, Vector3 position, const string &id);

    ~PAtom();

    string getID()const { return m_id; }

    void changePosition(const Vector3 &newPosition);

    void ApplyTransform(const Matrix4 &transform);

    AtomSet* getAllCollidingStatic() const;

    AtomSet* getAllCollidingSelf() const;

    AtomSet* getAllCollidingEither() const;

    PBond *getBond(PResidue *res, const string &id);
    
    PAtom *FindStaticCollision() const;

    PAtom *FindSelfCollision() const;

    PAtom *FindAnyCollision() const;

    bool InStaticCollision() const;

    bool InSelfCollision() const;

    bool InAnyCollision() const;

    bool isOnBackbone() const;
      
    PBlock *getParentBlock() { return m_atomBlock; }

    PResidue *getParentResidue();

    PChain *getChain() const;

    Vector3 getPos() const { return m_atomPos; }

    const vector<PBond *> *getBonds() const { return &m_bonds; }

    Real getCovalentRadius() const { return m_atomShell->getCovalentRadius(); }

    Real getVanDerWaalsRadius() const { return m_atomShell->getVanDerWaalsRadius(); }

    Real getOccupancy() const { return m_occupancy; }

    void setOccupancy(Real newVal) { m_occupancy = newVal; }

    Real getTempFactor() const { return m_tempFactor; }

    void setTempFactor(Real newVal) { m_tempFactor = newVal; }

    void setColor(const GLColor setColor) {m_colorSet=true; m_atomColor = setColor;}

    void revertColor(){ m_colorSet=false; }

    GLColor getColor() const {
      if (m_colorSet) { 
        return m_atomColor;
      } else { 
        return m_atomShell->getColor();
      }
    }

    string getName() const { return m_atomShell->getName(); }

    Vector3 getGridPos() const;

    bool WithinActiveBlock() const;

    bool isBonded(const PAtom *other) const;

    static int shortestBondPath(const PAtom *a1, const PAtom *a2, int threshold = -1);

    void traverseChain(AtomFunctor *atomFn, BondFunctor *bondFn);

    void traverseAtoms(AtomFunctor *atomFn) { traverseChain(atomFn, NULL); }

    void traverseBonds(BondFunctor *bondFn) { traverseChain(NULL, bondFn); }

    const PSpaceManager* getSpaceManager() const;

    bool isActive() const { return m_active; }

    void inactivate() { m_active = false; }

    void activate() { m_active = true; }

  private:

    /* Helper functions. */
    void insertMeIntoGrid();
    void removeMeFromGrid();
    
    /* Called by PResidue. */
    void DestroyBonds();

    Vector3 m_atomPos;
    string m_id;
    PAtomShell *m_atomShell;
    vector<PBond *> m_bonds;
    PBlock *m_atomBlock;
    PGrid *m_grid;
    bool m_colorSet;
    GLColor m_atomColor;
    Real m_tempFactor, m_occupancy;
   
    void internalTraverse(AtomFunctor *atomFn,
                          BondFunctor *bondFn,
                          AtomSet &atomsTraversed,
                          PChain *rootChain,
                          PBond *bondFrom);

    bool m_active;
};

#endif  // __P_ATOM_H

---