calculation.h

Go to the documentation of this file.

/***************************************************************************
                         calculation.h  -  description
                             -------------------
    begin                : Thu April 28 2005
    copyright            : (C) 2005-2006 by Ben Swerts
    email                : bswerts@users.sourceforge.net
 ***************************************************************************/

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


#ifndef CALCULATION_H
#define CALCULATION_H


// STL header files
#include <list>
#include <vector>

// Qt forward class declarations & header files
class QDomElement;
class QProcess;
#include <qstringlist.h>
class QWidget;

// Xbrabo forward class declarations
class AtomSet;

// Base class header file
#include <qobject.h>

class Calculation : public QObject
{
  Q_OBJECT

  public:
    // constructor/destructor
    Calculation(AtomSet* atomset, QWidget* parent = 0, const char* name = 0);   // constructor
    ~Calculation();                     // destructor
   
    // public enums
    enum Errors{NoError, UndefinedError, NoConvergence, CloseNuclei, MaxCyclesExceeded, ManualStop}; 

    // public member functions for starting/stopping the calculation
    bool start();                       // starts the calculation
    bool pause();                       // pauses the calculation
    bool stop();                        // stops the calculation (ask whether to stop immediately or after the current step is finished)

    // public member functions for setting up the calculation
    void setModified(const bool status = true);   // sets the 'modified' status of the calculation
    void setBraboInput(const QStringList stdInput, const QStringList basissets, const QString startVector, const bool preferStartVector, const unsigned int startVectorSize1, const unsigned int startVectorSize2);         // sets the BRABO input file, the list of basisets to be used and the place where the starting vector should be copied from
    void setStockInput(const QStringList stin, const QString atdens = QString::null); // sets the STOCK input file and the specific atdens file
    void setRelaxInput(const QStringList aff, const QStringList maff, const unsigned int updateFreq, const unsigned int maxSteps, const std::vector<unsigned int>& steps, const std::vector<double>& factors);    // sets the Relax AFF (header) file, its update frequency and scalefactor info
    void setCalculationType(const unsigned int type, const unsigned int buur); // SPE/OPT/FREQ, NoBuur/PC/SM
    void setParameters(const QString name, const QString dir, const bool format);         // Some more needed parameters
    void setBackup(const unsigned int freq, const bool brabo = false, const bool stock = false, const bool relax = false, const bool aff = false, const bool crd = false);// Sets the backup options
    void setContinuable(const bool status);       // Sets whether an optimization can be continued after having it stopped.

    // public member functions for returning data
    bool isRunning() const;             // returns whether the calculation is running
    bool isPaused() const;              // returns whether the calculation is paused
    void getRefinementParameters(bool& largestCart, bool& magnCart, bool& largestInt, bool& magnInt, bool& largestShift);         // Returns the 5 refinement criteria for the latest cycle
    void getAvailableOutputs(std::vector<unsigned int>& cycles, std::vector<bool>& brabo, std::vector<bool>& stock, std::vector<bool>& relax, std::vector<bool>& aff);    // Returns the cycles for which outputs are available
    QStringList braboOutput(const unsigned int step = 0);   // Returns the contents of the Brabo output file for a step
    QStringList stockOutput(const unsigned int step = 0);   // Returns the contents of the Stock output file for a step
    QStringList relaxOutput(const unsigned int step = 0);   // Returns the contents of the Relax output file for a step
    QStringList affOutput(const unsigned int step = 0);     // Returns the contents of the AFF file for a step

    // public member functions for IO
    void loadCML(const QDomElement* root);        // loads the settings from file
    void saveCML(QDomElement* root);    // saves the settings to file 
    void writeInput();                  // writes all input files
    void clean();                       // cleans up the calculation directory

  signals:
    void newIteration(unsigned int, double);      
    void newCycle(unsigned int);        
    void updated();                     
    void finished(unsigned int error);  
    void modified();                    

  private slots:
    void finishBrabo();                 // Does cleanup of a BRABO run
    void readStdOutBrabo();             // Reads output from the process running BRABO
    void finishStock();                 // Does cleanup of a STOCK run
    void finishMAFF();                  // Does cleanup of a MAFF run
    void finishCnvrtAFF();              // Does cleanup of a CNVRTAFF run
    void finishRelax();                 // Does cleanup of a RELAX run
    void readStdOutAll();               // Reads output from the process without checking the contents

  private:
    // private enums
    enum CalculationStep{NEW_CYCLE, ACHAR, BRABO, BUUR, CNVRTAFF, DISTOR, FORKON, MAFF, RELAX, STOCK, UPDATE};        

    // private member functions
    bool checkBasissets();              // checks whether all basisset files given in basissetList exist
    bool checkExecutables();            // checks whether all needed executables are present
    bool makeDirCurrent(const QString dir, const QString title);      // switches to the desired directory
    bool copyStartVector();             // copies startVectorFile to the calculation directory
    void doNextStep();                  // starts the next step of the calculation
    void runBrabo();                    // starts a BRABO run
    void runStock();                    // starts a STOCK run
    void runMAFF();                     // starts a MAFF run
    void runCnvrtAFF();                 // starts a CNVRTAFF run
    void runRelax();                    // starts a RELAX run
    void runCleanup();                  // cleanup at the end of a calculation
    void runUpdate();                   // updates the AtomSet with the newly calculated properties (and coordinates)
    double scaleFactor(const unsigned int step);  // returns the scalefactor corresponding to the optimization step
    void backupOutputs();               // does a backup of requested output files
    bool copyFile(const QString source, const QString destination);   // blocking copy
    QStringList output(const QString extension, const unsigned int step = 0);     // Returns the contents of a file with the given extension for a certain step
    std::vector<double> loadFromPunch(const QString code, const unsigned int numValues, const unsigned int fieldSize, const unsigned int fieldsPerLine);        // Reads data from the punch file in fixed format

    // private member data
    AtomSet* atoms;                     
    QWidget* parentWidget;              
    QStringList braboInput;             
    QStringList stockInput;             
    QStringList relaxInput;             
    QStringList maffInput;              
    QStringList basissetList;           
    QString startVectorFile;            
    QString atdensFile;                 
    unsigned int affUpdateFreq;         
    unsigned int calculationType;       
    unsigned int crystalType;           
    bool updateBraboInput;              
    bool updateStockInput;              
    bool updateRelaxInput;              
    bool doBasissetCheck;               
    bool copyAtdens;                    
    bool calcRunning;                   
    bool calcPaused;                    
    QString calcName;                   
    QString calcDir;                    
    QProcess* calcProcess;              
    unsigned int calcMaxCycle;          
    bool calcXF;                        
    unsigned int currentCycle;          
    bool calcSuccess;                   
    std::list<CalculationStep> calculationSteps;  
    std::vector<unsigned int> scaleSteps;         
    std::vector<double> scaleFactors;             
    bool stopRequested;                 
    unsigned int backupFrequency;       
    bool backupBrabo;                   
    bool backupStock;                   
    bool backupRelax;                   
    bool backupAFF;                     
    bool backupCRD;                     
    bool calcModified;                  
    unsigned int calcError;             
    bool calcContinuable;               
};

#endif

---