src/globalsearch/structure.h

/**********************************************************************
  Structure - Generic wrapper for Avogadro's molecule class

  Copyright (C) 2009-2011 by David C. Lonie

  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 version 2 of the License.

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

#ifndef STRUCTURE_H
#define STRUCTURE_H

#include <avogadro/molecule.h>
#include <avogadro/atom.h>

#include <openbabel/math/vector3.h>
#include <openbabel/mol.h>
#include <openbabel/generic.h>

#include <QtCore/QDebug>
#include <QtCore/QDateTime>
#include <QtCore/QHash>
#include <QtCore/QTextStream>

#include <vector>

// source: http://en.wikipedia.org/wiki/Electronvolt
#define EV_TO_KJ_PER_MOL 96.4853365
#define KJ_PER_MOL_TO_EV 0.0103642692

namespace GlobalSearch {

  class Structure : public Avogadro::Molecule
  {
    Q_OBJECT

   public:

    Structure(QObject *parent = 0);

    Structure(const Structure &other);

    Structure(const Avogadro::Molecule &other);

    virtual ~Structure();

    Structure& operator=(const Structure& other);

    Structure& operator=(const Avogadro::Molecule& other);

    virtual Structure& copyStructure(const Structure &other);

    enum State {
      Optimized = 0,
      StepOptimized,
      WaitingForOptimization,
      InProcess,
      Empty,
      Updating,
      Error,
      Submitted,
      Killed,
      Removed,
      Duplicate,
      Restart,
      Preoptimizing
    };

    bool hasBestOffspring() const {return m_hasBestOffspring;}

    bool hasEnthalpy()  const {return m_hasEnthalpy;};

    double getEnergy()  const {return energy(0) * KJ_PER_MOL_TO_EV;};

    double getEnthalpy()const {if (!m_hasEnthalpy) return getEnergy(); return m_enthalpy;};

    double getPV()      const {return m_PV;};

    uint getRank()      const {return m_rank;};

    uint getJobID()     const {return m_jobID;};

    uint getGeneration() const {return m_generation;};

    uint getIDNumber() const {return m_id;};

    int getIndex() const {return m_index;};

    QString getDuplicateString() const {return m_dupString;};

    QString getParents() const {return m_parents;};

    QString getRempath() const {return m_rempath;};

    State getStatus()   const {return m_status;};

    uint getCurrentOptStep() {return m_currentOptStep;};

    virtual bool isPreoptimizing() const {return false;}

    virtual int getPreOptProgress() const {return -1;}

    virtual bool needsPreoptimization() const {return false;}

    uint getFailCount() { return m_failCount;};

    QDateTime getOptTimerStart() const {return m_optStart;};

    QDateTime getOptTimerEnd() const {return m_optEnd;};

    QString getIDString() const {
      return tr("%1x%2").arg(getGeneration()).arg(getIDNumber());};

    virtual QString getResultsHeader() const {
      return QString("%1 %2 %3 %4 %5")
        .arg("Rank", 6)
        .arg("Gen", 6)
        .arg("ID", 6)
        .arg("Enthalpy", 10)
        .arg("Status", 11);};

    virtual QString getResultsEntry() const;

    QHash<int, int> * getOptimizerLookupTable()
    {
      return &m_optimizerLookup;
    }

    void resetOptimizerLookupTable()
    {
      m_optimizerLookup.clear();
      for (int i = 0; i < m_atomList.size(); ++i)
        m_optimizerLookup.insert(i,i);
    }

    virtual bool getNearestNeighborDistances(QList<double> * list) const;

    virtual bool getShortestInteratomicDistance(double & shortest) const;

    virtual bool getNearestNeighborDistance(const double x,
                                            const double y,
                                            const double z,
                                            double & shortest) const;

    virtual bool getNearestNeighborDistance(const Avogadro::Atom *atom,
                                            double & shortest) const;

    QList<Avogadro::Atom*> getNeighbors (const double x,
                                         const double y,
                                         const double z,
                                         const double cutoff,
                                         QList<double> *distances = 0) const;

    QList<Avogadro::Atom*> getNeighbors (const Avogadro::Atom *atom,
                                         const double cutoff,
                                         QList<double> *distances = 0) const;

    virtual void getDefaultHistogram(QList<double> *dist, QList<double> *freq) const;

    virtual void getDefaultHistogram(QList<QVariant> *dist, QList<QVariant> *freq) const;

    virtual bool isHistogramGenerationPending() const {
      return m_histogramGenerationPending;};

    virtual bool generateIADHistogram(QList<double> * distance,
                                      QList<double> * frequency,
                                      double min = 0.0,
                                      double max = 10.0,
                                      double step = 0.01,
                                      Avogadro::Atom *atom = 0) const;

    virtual bool generateIADHistogram(QList<QVariant> * distance,
                                      QList<QVariant> * frequency,
                                      double min = 0.0,
                                      double max = 10.0,
                                      double step = 0.01,
                                      Avogadro::Atom *atom = 0) const;

    virtual bool addAtomRandomly(uint atomicNumber,
                                 double minIAD = 0.0,
                                 double maxIAD = 0.0,
                                 int maxAttempts = 1000,
                                 Avogadro::Atom **atom = 0);

    QList<QString> getSymbols() const;

    QList<uint> getNumberOfAtomsAlpha() const;

    QString getOptElapsed() const;

    virtual QHash<QString, QVariant> getFingerprint() const;

    bool hasChangedSinceDupChecked() {return m_updatedSinceDupChecked;};

    static void sortByEnthalpy(QList<Structure*> *structures);

    static void rankByEnthalpy(const QList<Structure*> &structures);

    static void sortAndRankByEnthalpy(QList<Structure*> *structures);

  signals:
    void preoptimizationStarted();
    void preoptimizationFinished();

   public slots:

    virtual void setupConnections();

    virtual void enableAutoHistogramGeneration(bool);

    virtual void requestHistogramGeneration();

    virtual void generateDefaultHistogram();

    virtual void structureChanged();

    static bool compareIADDistributions(const std::vector<double> &d,
                                        const std::vector<double> &f1,
                                        const std::vector<double> &f2,
                                        double decay,
                                        double smear,
                                        double *error);
    static bool compareIADDistributions(const QList<double> &d,
                                        const QList<double> &f1,
                                        const QList<double> &f2,
                                        double decay,
                                        double smear,
                                        double *error);

    static bool compareIADDistributions(const QList<QVariant> &d,
                                        const QList<QVariant> &f1,
                                        const QList<QVariant> &f2,
                                        double decay,
                                        double smear,
                                        double *error);

    virtual void writeSettings(const QString &filename) {
      writeStructureSettings(filename);};

    virtual void readSettings(const QString &filename) {
      readStructureSettings(filename);};

    virtual void updateAndSkipHistory(const QList<unsigned int> &atomicNums,
                                      const QList<Eigen::Vector3d> &coords,
                                      const double energy = 0,
                                      const double enthalpy = 0,
                                      const Eigen::Matrix3d &cell = Eigen::Matrix3d::Zero());

    virtual void updateAndAddToHistory(const QList<unsigned int> &atomicNums,
                                       const QList<Eigen::Vector3d> &coords,
                                       const double energy = 0,
                                       const double enthalpy = 0,
                                       const Eigen::Matrix3d &cell = Eigen::Matrix3d::Zero());

    virtual void deleteFromHistory(unsigned int index);

    virtual void retrieveHistoryEntry(unsigned int index,
                                      QList<unsigned int> *atomicNums,
                                      QList<Eigen::Vector3d> *coords,
                                      double *energy,
                                      double *enthalpy,
                                      Eigen::Matrix3d *cell);

    virtual unsigned int sizeOfHistory() {return m_histEnergies.size();};

    void setHasBestOffspring(bool b = true)
    {
      m_hasBestOffspring = b;
    }

    void setEnthalpy(double enthalpy) {m_hasEnthalpy = true; m_enthalpy = enthalpy;};

    void setPV(double pv) {m_PV = pv;};

    void resetEnthalpy() {m_enthalpy=0; m_PV=0; m_hasEnthalpy=false;};

    void resetEnergy() {std::vector<double> E; E.push_back(0); setEnergies(E);};

    void setOBEnergy(const QString &ff = QString("UFF"));

    void setRank(uint rank) {m_rank = rank;};

    void setJobID(uint id) {m_jobID = id;};

    void setGeneration(uint gen) {m_generation = gen;};

    void setIDNumber(uint id) {m_id = id;};

    void setIndex(int index) {m_index = index;};

    void setParents(const QString & p) {m_parents = p;};

    void setRempath(const QString & p) {m_rempath = p;};

    void setStatus(State status) {m_status = status;};

    void setCurrentOptStep(uint i) {m_currentOptStep = i;};

    void setFailCount(uint count) {m_failCount = count;};

    void resetFailCount() {setFailCount(0);};

    void addFailure() {setFailCount(getFailCount() + 1);};

    void setDuplicateString(const QString & s) {m_dupString = s;};

    void setChangedSinceDupChecked(bool b) {m_updatedSinceDupChecked = b;};

    void startOptTimer() {
      m_optStart = QDateTime::currentDateTime(); m_optEnd = QDateTime();};

    void stopOptTimer() {
      if (m_optEnd.isNull()) m_optEnd = QDateTime::currentDateTime();};

    void setOptTimerStart(const QDateTime &d) {m_optStart = d;};

    void setOptTimerEnd(const QDateTime &d) {m_optEnd = d;};


    virtual void setNeedsPreoptimization(bool b)
    {
      Q_UNUSED(b);
      qWarning() << "Preoptimization is not implemented for all structure "
                    "types. Call to Structure::setNeedsPreoptimization "
                    "ignored.";
    }

    virtual void abortPreoptimization() const {};

    void emitPreoptimizationStarted()
    {
      emit preoptimizationStarted();
    }

    void emitPreoptimizationFinished()
    {
      emit preoptimizationFinished();
    }

    virtual void load(QTextStream &in);

   protected slots:
    void writeStructureSettings(const QString &filename);

    void readStructureSettings(const QString &filename);

  protected:
    // skip Doxygen parsing
    bool m_hasEnthalpy, m_updatedSinceDupChecked;
    bool m_histogramGenerationPending;
    bool m_hasBestOffspring;
    uint m_generation, m_id, m_rank, m_jobID, m_currentOptStep, m_failCount;
    QString m_parents, m_dupString, m_rempath;
    double m_enthalpy, m_PV;
    State m_status;
    QDateTime m_optStart, m_optEnd;
    int m_index;
    QList<QVariant> m_histogramDist, m_histogramFreq;

    // History
    QList<QList<unsigned int> > m_histAtomicNums;
    QList<double> m_histEnthalpies;
    QList<double> m_histEnergies;
    QList<QList<Eigen::Vector3d> > m_histCoords;
    QList<Eigen::Matrix3d> m_histCells;

    // Map <Structure atom index, optimizer atom index>
    QHash<int, int> m_optimizerLookup;

    // End doxygen skip:
  };

} // end namespace GlobalSearch

#endif

---