/home/kitware/dashboards/avogadro/libavogadro/src/molecule.h

/**********************************************************************
  Molecule - Molecule class derived from the base Primitive class

  Copyright (C) 2007 Donald Ephraim Curtis
  Copyright (C) 2008-2009 Marcus D. Hanwell

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.openmolecules.net/>

  Avogadro 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.

  Avogadro 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 MOLECULE_H
#define MOLECULE_H

#include <avogadro/primitive.h>

// Used by the inline functions
#include <QReadWriteLock>

#include <vector>

namespace OpenBabel {
  class OBAtom;
  class OBBond;
  class OBMol;
  class OBUnitCell;
}

namespace Avogadro {

  // Declare new classes
  class Atom;
  class Bond;
  class Cube;
  class Fragment;
  class Mesh;
  class PrimitiveList;
  class Residue;
  class ZMatrix;

  class MoleculePrivate;
  class A_EXPORT Molecule : public Primitive
  {
  Q_OBJECT
  public:
    Molecule(QObject *parent=0);

    Molecule(const Molecule &other);

    virtual ~Molecule();

    void update();

    void setFileName(const QString& name);

    QString fileName() const;
    Atom *addAtom();

    Atom *addAtom(unsigned long id);

    Atom *addAtom(int atomicNum, const Eigen::Vector3d &pos);

    Atom *addAtom(const Atom &other);

    void removeAtom(Atom *atom);

    void removeAtom(unsigned long id);

    Atom * atom(int index) const;

    Atom *atomById(unsigned long id) const;

    QList<Atom *> atoms() const;

    void setAtomPos(unsigned long id, const Eigen::Vector3d &vec);

    void setAtomPos(unsigned long id, const Eigen::Vector3d *vec);

    const Eigen::Vector3d * atomPos(unsigned long id) const;

    unsigned int numAtoms() const;

    Bond *addBond();

    Bond *addBond(unsigned long id);

    Bond *addBond(unsigned long beginAtomId, unsigned long endAtomId,
                  short order = 1);

    Bond *addBond(Atom *beginAtom, Atom* endAtom, short order = 1);

    void removeBond(Bond *bond);

    void removeBond(unsigned long id);

    Bond* bond(int index) const;

    Bond *bondById(unsigned long id) const;

    QList<Bond *> bonds() const;

    unsigned int numBonds() const;

    Residue *addResidue();

    Residue *addResidue(unsigned long id);

    void removeResidue(Residue *residue);

    void removeResidue(unsigned long id);

    Residue* residue(int index);
    const Residue* residue(int index) const;

    Residue *residueById(unsigned long id) const;

    QList<Residue *> residues() const;

    unsigned int numResidues() const;
    Fragment *addRing();

    Fragment *addRing(unsigned long id);

    void removeRing(Fragment *ring);

    void removeRing(unsigned long id);

    QList<Fragment *> rings();

    unsigned int numRings() const;
    Cube *addCube();

    Cube *addCube(unsigned long id);

    void removeCube(Cube *cube);

    void removeCube(unsigned long id);

    Cube* cube(int index) const;

    Cube *cubeById(unsigned long id) const;

    QList<Cube *> cubes() const;

    unsigned int numCubes() const;
    Mesh * addMesh();

    Mesh *addMesh(unsigned long id);

    void removeMesh(Mesh *mesh);

    void removeMesh(unsigned long id);

    Mesh* mesh(int index) const;

    Mesh *meshById(unsigned long id) const;

    QList<Mesh *> meshes() const;

    unsigned int numMeshes() const;
    ZMatrix * addZMatrix();

    void removeZMatrix(ZMatrix *zmatrix);

    ZMatrix * zMatrix(int index) const;

    QList<ZMatrix *> zMatrices() const;

    unsigned int numZMatrices() const;
    void addHydrogens(Atom *atom = 0,
                      const QList<unsigned long> &atomIds = QList<unsigned long>(),
                      const QList<unsigned long> &bondIds = QList<unsigned long>());

    void removeHydrogens(Atom *atom = 0);

    void setDipoleMoment(const Eigen::Vector3d &moment);

    Eigen::Vector3d dipoleMoment(bool *estimate = 0) const;

    void calculatePartialCharges() const;

    void calculateAromaticity() const;

    void calculateGroupIndices() const;

    Bond* bond(unsigned long id1, unsigned long id2);

    Bond* bond(const Atom*, const Atom*);

    unsigned long conformerSize() { return m_atomPos->size(); }

    bool addConformer(const std::vector<Eigen::Vector3d> &conformer,
                      unsigned int index);

    std::vector<Eigen::Vector3d> * addConformer(unsigned int index);

    std::vector<Eigen::Vector3d> * conformer(unsigned int index);

    const std::vector<std::vector<Eigen::Vector3d> *>& conformers() const;

    bool setConformer(unsigned int index);

    bool setAllConformers(const std::vector< std::vector<Eigen::Vector3d>* > conformers, bool deleteExisting = true);

    void clearConformers();

    unsigned int numConformers() const;

    unsigned int currentConformer() const;

    const std::vector<double>& energies() const;

    double energy(int index = -1) const;

    void setEnergy(double energy);

    void setEnergy(int index, double energy);

    void setEnergies(const std::vector<double>& energies);

    void clear();

    QReadWriteLock *lock() const;

    OpenBabel::OBMol OBMol() const;

    bool setOBMol(OpenBabel::OBMol *obmol);

    OpenBabel::OBUnitCell *OBUnitCell() const;

    bool setOBUnitCell(OpenBabel::OBUnitCell *obunitcell);
    const Eigen::Vector3d center() const;

    const Eigen::Vector3d normalVector() const;

    double radius() const;

    const Atom *farthestAtom() const;

    void translate(const Eigen::Vector3d&);
    Molecule& operator=(const Molecule& other);

    Molecule& operator+=(const Molecule& other);
    PrimitiveList copyAtomsAndBonds(const QList<Atom*> &atoms,
                                    const QList<Bond*> &bonds);

    PrimitiveList copyAtomsAndBonds(const PrimitiveList &atomsAndBonds);
  protected:
    MoleculePrivate * const d_ptr;
    QString m_fileName;
    std::vector<Eigen::Vector3d> *m_atomPos; // Atom position vector
    std::vector< std::vector<Eigen::Vector3d>* > m_atomConformers;
    mutable unsigned int m_currentConformer;

    mutable bool m_estimatedDipoleMoment;
    mutable Eigen::Vector3d *m_dipoleMoment;
    mutable bool m_invalidPartialCharges;
    mutable bool m_invalidAromaticity;
    Q_DECLARE_PRIVATE(Molecule)

    std::vector<Atom *>   m_atoms;
    std::vector<Bond *>   m_bonds;
    QList<Atom *>         m_atomList;
    QList<Bond *>         m_bondList;

    QReadWriteLock *m_lock;

    void computeGeomInfo() const;

  public Q_SLOTS:
    void updateMolecule();

  private Q_SLOTS:
    void updatePrimitive();

    void updateAtom();

    void updateBond();

  Q_SIGNALS:
    void moleculeChanged();

    void primitiveAdded(Primitive *primitive);

    void primitiveUpdated(Primitive *primitive);

    void primitiveRemoved(Primitive *primitive);

    void atomAdded(Atom *atom);

    void atomUpdated(Atom *atom);

    void atomRemoved(Atom *atom);

    void bondAdded(Bond *bond);

    void bondUpdated(Bond *bond);

    void bondRemoved(Bond *bond);
  };

  inline Atom * Molecule::atom(int index) const
  {
    if (index >= 0 && index < m_atomList.size())
      return m_atomList[index];
    else
      return 0;
  }

  inline Atom * Molecule::atomById(unsigned long id) const
  {
    if(id < m_atoms.size() && id != FALSE_ID)
      return m_atoms[id];
    else
      return 0;
  }

  inline const Eigen::Vector3d * Molecule::atomPos(unsigned long id) const
  {
    if (id < m_atomPos->size() && id != FALSE_ID)
      return &(*m_atomPos)[id];
    else
      return 0;
  }

  inline Bond * Molecule::bond(int index) const
  {
    if (index >= 0 && index < m_bondList.size())
      return m_bondList[index];
    else
      return 0;
  }

  inline Bond * Molecule::bondById(unsigned long id) const
  {
    if(id < m_bonds.size() && id != FALSE_ID)
      return m_bonds[id];
    else
      return 0;
  }

} // End namespace Avogadro

#endif