atom.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: atom.h,v 1.75.14.1 2007/03/25 21:23:43 oliver Exp $
//

#ifndef BALL_KERNEL_ATOM_H
#define BALL_KERNEL_ATOM_H

#ifndef BALL_CONCEPT_COMPOSITE_H
# include <BALL/CONCEPT/composite.h>
#endif

#ifndef BALL_CONCEPT_PROPERTY_H
# include <BALL/CONCEPT/property.h>
#endif

#ifndef BALL_CONCEPT_RANDOMACCESSITERATOR_H
# include <BALL/CONCEPT/randomAccessIterator.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

// Defines for default values for an atom
#define BALL_ATOM_DEFAULT_ELEMENT &Element::UNKNOWN
#define BALL_ATOM_DEFAULT_CHARGE     0
#define BALL_ATOM_DEFAULT_FORMAL_CHARGE     0
#define BALL_ATOM_DEFAULT_NAME       ""
#define BALL_ATOM_DEFAULT_TYPE_NAME  "?"
#define BALL_ATOM_DEFAULT_POSITION   0,0,0
#define BALL_ATOM_DEFAULT_RADIUS     0
#define BALL_ATOM_DEFAULT_TYPE       Atom::UNKNOWN_TYPE
#define BALL_ATOM_DEFAULT_VELOCITY   0,0,0
#define BALL_ATOM_DEFAULT_FORCE      0,0,0

namespace BALL
{
  class Bond;
  class Element;
  class Fragment;
  class Residue;
  class Chain;
  class SecondaryStructure;
  class Molecule;

  class BALL_EXPORT Atom
    : public Composite,
      public PropertyManager
  {
    public:

      friend class Bond;

      BALL_CREATE_DEEP(Atom)

      
      typedef short Type;


      enum
      {
        UNKNOWN_TYPE = -1,

        ANY_TYPE = 0,

        MAX_NUMBER_OF_BONDS = 12
      };

      enum Property
      {
        NUMBER_OF_PROPERTIES = 0
      };

      enum FullNameType
      {
        // Do not add extensions
        NO_VARIANT_EXTENSIONS,
        // Add the residue extensions
        ADD_VARIANT_EXTENSIONS,
        // Add the residue ID
        ADD_RESIDUE_ID,
        // Add the residue ID and the residue extension
        ADD_VARIANT_EXTENSIONS_AND_ID,
        // Add the chain ID and the residue ID 
        ADD_CHAIN_RESIDUE_ID,
        // Add the chain ID and the residue ID 
        ADD_VARIANT_EXTENSIONS_AND_CHAIN_RESIDUE_ID
      };



      Atom();

      Atom(const Atom& atom, bool deep = true);

      Atom(Element& element,
           const String& name, const String& type_name = BALL_ATOM_DEFAULT_TYPE_NAME,
           Type atom_type = BALL_ATOM_DEFAULT_TYPE,
           const Vector3& position = Vector3(BALL_ATOM_DEFAULT_POSITION),
           const Vector3& velocity = Vector3(BALL_ATOM_DEFAULT_VELOCITY),
           const Vector3& force = Vector3(BALL_ATOM_DEFAULT_FORCE),
           float charge = BALL_ATOM_DEFAULT_CHARGE,
           float radius = BALL_ATOM_DEFAULT_RADIUS,
           Index formal_charge = BALL_ATOM_DEFAULT_FORMAL_CHARGE);



      virtual ~Atom();

      virtual void clear();

      virtual void destroy();



      virtual void persistentWrite(PersistenceManager& pm, const char* name = 0) const
        throw(Exception::GeneralException);

      virtual void persistentRead(PersistenceManager& pm)
        throw(Exception::GeneralException);



      void set(const Atom& atom, bool deep = true);

      void get(Atom& atom, bool deep = true) const;

      Atom& operator = (const Atom& atom);

      void swap(Atom& atom);



      bool operator == (const Atom& atom) const;

      bool operator != (const Atom& atom) const;



      void setElement(const Element& element);

      const Element& getElement() const;

      void setCharge(float charge);

      float getCharge() const;

      void setFormalCharge(Index formal_charge);

      Index getFormalCharge() const;

      const Molecule* getMolecule() const;
      Molecule* getMolecule();


      const Fragment* getFragment() const;
      Fragment* getFragment();

      const Residue* getResidue() const;
      Residue* getResidue();

      const SecondaryStructure* getSecondaryStructure() const;
      SecondaryStructure* getSecondaryStructure();

      const Chain* getChain() const;
      Chain* getChain();

      void setName(const String& name);

      const String& getName() const;

      String getFullName(FullNameType type = ADD_VARIANT_EXTENSIONS) const;

      void setPosition(const Vector3& position);

      Vector3& getPosition();

      const Vector3& getPosition() const;

      void setRadius(float radius);

      float getRadius() const;

      void setType(Type atom_type);

      Type getType() const;

      String getTypeName() const;

      void setTypeName(const String& name);

      void setVelocity(const Vector3& velocity);

      const Vector3& getVelocity() const;

      void setForce(const Vector3& force);
      const Vector3& getForce() const;
      Vector3& getForce();


      Size countBonds() const;

      Bond* getBond(Position index)
        throw(Exception::IndexOverflow);

      const Bond* getBond(Position index) const
        throw(Exception::IndexOverflow);

      Bond* getBond(const Atom& atom);

      const Bond* getBond(const Atom& atom) const;



      Bond* createBond(Atom& atom)
        throw(Exception::TooManyBonds);

      Bond* createBond(Bond& bond, Atom& atom)
        throw(Exception::TooManyBonds);

      Bond* cloneBond(Bond& bond, Atom& atom);

      bool destroyBond(const Atom& atom);

      void destroyBonds();

      Atom* getPartnerAtom(Position i) throw(Exception::IndexOverflow);

      const Atom* getPartnerAtom(Position i) const throw(Exception::IndexOverflow);

      float getDistance(const Atom& a) const;



      bool hasBond(const Bond& bond) const;

      bool isBoundTo(const Atom& atom) const;

      bool isBound() const;

      bool isGeminal(const Atom& atom) const;

      bool isVicinal(const Atom& atom) const;


      virtual bool isValid() const;

      virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;


      bool applyBonds(UnaryProcessor<Bond>& processor);



      typedef Index BondIteratorPosition;

      class BALL_EXPORT BondIteratorTraits
      {
        public:

        BALL_CREATE_DEEP(BondIteratorTraits)

        virtual ~BondIteratorTraits()  {}

        BondIteratorTraits()
          : bound_(0),
            position_(0)
        {
        }

        BondIteratorTraits(const Atom& atom)
          : bound_((Atom*)&atom),
            position_(0)
        {
        }

        BondIteratorTraits(const BondIteratorTraits& traits, bool /* deep */ = true)
          : bound_(traits.bound_),
            position_(traits.position_)
        {
        }

        BondIteratorTraits& operator = (const BondIteratorTraits& traits)
        {
          bound_ = traits.bound_;
          position_ = traits.position_;
          return *this;
        }

        Atom* getContainer() { return bound_; }

        const Atom* getContainer() const { return bound_; }

        bool isSingular() const { return (bound_ == 0); }

        BondIteratorPosition& getPosition() { return position_; }

        const BondIteratorPosition& getPosition() const { return position_; }

        // Comparison: We do net check whether these traits are bound to
        // the same container here for efficiency reasons.

        bool operator == (const BondIteratorTraits& traits) const
        {
          return (position_ == traits.position_);
        }

        bool operator != (const BondIteratorTraits& traits) const
        {
          return !(position_ == traits.position_);
        }

        bool operator < (const BondIteratorTraits& traits) const
        {
          return (position_ < traits.position_);
        }

        Distance getDistance(const BondIteratorTraits& traits) const
        {
          return (Distance)(position_ - traits.position_);
        }

        bool isValid() const
        {
          return (bound_ != 0 && position_ >= 0 && position_ < bound_->number_of_bonds_);
        }

        void invalidate()
        {
          bound_ = 0;
          position_ = 0;
        }

        void toBegin() { position_ = 0; }

        bool isBegin() const { return (position_ == 0); }

        void toEnd() { position_ = bound_->number_of_bonds_; }

        bool isEnd() const { return (position_ >= bound_->number_of_bonds_);}

        Bond& getData() { return *(bound_->bond_[position_]); }

        const Bond& getData() const { return *(bound_->bond_[position_]); }

        void forward() { ++position_; }

        friend std::ostream& operator << (std::ostream& s, const BondIteratorTraits& traits)
        {
          return (s << traits.position_ << ' ');
        }

        void dump(std::ostream& s) const
        {
          s << position_ << std::endl;
        }

        void toRBegin()
        {
          position_ = bound_->number_of_bonds_ - 1;
        }

        bool isRBegin() const
        {
          return (position_ == bound_->number_of_bonds_ - 1);
        }

        void toREnd()
        {
          position_ = -1;
        }

        bool isREnd() const
        {
          return (position_ <= -1);
        }

        void backward()
        {
          --position_;
        }

        void backward(Distance distance)
        {
          position_ -= distance;
        }

        void forward(Distance distance)
        {
          position_ += distance;
        }

        Bond& getData(Index index)
        {
          return *(bound_->bond_[index]);
        }

        const Bond& getData(Index index) const
        {
          return *(bound_->bond_[index]);
        }

        private:

        Atom* bound_;
        BondIteratorPosition position_;

      };

      friend class BondIteratorTraits;

      typedef RandomAccessIterator
        <Atom, Bond, BondIteratorPosition, BondIteratorTraits>
        BondIterator;

      BondIterator beginBond()
      {
        return BondIterator::begin(*this);
      }

      BondIterator endBond()
      {
        return BondIterator::end(*this);
      }

      typedef ConstRandomAccessIterator
        <Atom, Bond, BondIteratorPosition, BondIteratorTraits>
        BondConstIterator;

      BondConstIterator beginBond() const
      {
        return BondConstIterator::begin(*this);
      }

      BondConstIterator endBond() const
      {
        return BondConstIterator::end(*this);
      }

      typedef std::reverse_iterator<BondIterator> BondReverseIterator;

      BondReverseIterator rbeginBond()
      {
        return BondReverseIterator(endBond());
      }

      BondReverseIterator rendBond()
      {
        return BondReverseIterator(beginBond());
      }

      typedef std::reverse_iterator<BondConstIterator> BondConstReverseIterator;

      BondConstReverseIterator rbeginBond() const
      {
        return BondConstReverseIterator(endBond());
      }

      BondConstReverseIterator rendBond() const
      {
        return BondConstReverseIterator(beginBond());
      }



    class BALL_EXPORT StaticAtomAttributes
    {
      public:
      Index           formal_charge;
      float           charge;
      Vector3         position;
      Type            type;
      Vector3         velocity;
      Vector3         force;
      Atom*           ptr;

      void clear();

      void swap(StaticAtomAttributes& attr);

      void set(StaticAtomAttributes& attr);

      StaticAtomAttributes& operator = (const StaticAtomAttributes& attr);
    };

    class BALL_EXPORT AttributeVector
      : public std::vector<StaticAtomAttributes>
    {
      public:
      ~AttributeVector();
    };

    typedef std::list<Atom*> AtomPtrList;

    typedef std::list<Position> AtomIndexList;

    static Position compact(const AtomIndexList& indices)
      throw(Exception::OutOfRange);

    static AttributeVector& getAttributes();

    Position getIndex() const;

    StaticAtomAttributes* getAttributePtr();
    const StaticAtomAttributes* getAttributePtr() const;

    static const PreciseTime& getAttributesModificationTime()
      { return attributes_changed_time_;}

    protected:



    static AttributeVector  static_attributes_;

    static AtomIndexList    free_list_;

    static PreciseTime attributes_changed_time_;

    Position        index_;
    const Element*  element_;
    String          name_;
    String          type_name_;
    float           radius_;
    unsigned char   number_of_bonds_;
    Bond*           bond_[MAX_NUMBER_OF_BONDS];

    private:

    static Position nextIndex_();

    static void freeIndex_(Position index);

    void clear_();

    void swapLastBond_(const Atom* atom);

  };

// required for visual studio
#ifdef BALL_COMPILER_MSVC
#include <vector>
template class BALL_EXPORT std::vector<Atom*>;
#endif

# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/KERNEL/atom.iC>
# endif
} // namespace BALL

#ifndef BALL_KERNEL_BONDITERATOR_H
# include <BALL/KERNEL/bondIterator.h>
#endif


#endif // BALL_KERNEL_ATOM_H