orbitalthread.h

Go to the documentation of this file.

/***************************************************************************
                       orbitalthread.h  -  description
                             -------------------
    begin                : Sun Mar 27 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 ORBITALTHREAD_H
#define ORBITALTHREAD_H


// STL header files
#include <vector>

// Qt forward class declarations
class QMutex;
class QWidget;

// Xbrabo header files
#include "point3d.h"

// Base class header files
#include <qthread.h>

class OrbitalThread : public QThread
{
  public:
    OrbitalThread(QWidget* parentWidget, QMutex* sharedMutex, std::vector<Point3D<float> >* coordinates, const unsigned int type, const unsigned int atom, const unsigned int n, const unsigned int l, const int m, const float res, const float prob, const unsigned int dots);        // constructor
    ~OrbitalThread();                   // destructor

    enum Types{IsoProbability = 0, Density, AngularPart, AccumulatedProbability, RadialPart}; 

    void stop();                        // requests stopping the thread
    double boundingSphereRadius();      // returns the radius of the bounding sphere

  private:
    // private enums
    enum Precision{PRECISION_UNKNOWN, PRECISION_FLOAT, PRECISION_DOUBLE, PRECISION_LONG_DOUBLE}; 

    virtual void run();                 // reimplementation of this pure virtual does the actual work
    void calcIsoProbability();          // calculates an isoprobability
    void calcAccumulatedProbability();  // calculates points with the given total accumulated probability
    void calcRandomDots();              // calculates random points according to the probability
    void calcRadialPart();              // calculates only the radial part of the orbital
    void calcAngularPart();             // calculates only the angular part of the orbital
    void updateList(std::vector<Point3D<float> >& newCoords, bool final = false);         // updates the shared list of coordinates with a new set
    float associatedLegendre(const float x, const int m, const unsigned int l); // returns the associated Legendre polynomial
    float associatedLaguerre(const float x, const int m, const unsigned int n); // returns the associated Laguerre polynomial
    template <class T> T factorial(const unsigned int number);        // returns the factorial (n!) of the number (n)
    float random(const float min, const float max);         // returns a random number between min and max
    template <class T> T largestResult(const unsigned int n, const unsigned int l, const int m, const unsigned int Z);  // calculates the largest possible result for the given quantum numbers

    QWidget* receiver;                  
    QMutex* mutex;                      
    std::vector<Point3D<float> >* coords;         
    unsigned int atomNumber;            
    unsigned int qnPrincipal;           
    unsigned int qnOrbital;             
    int qnMomentum;                     
    unsigned int calculationType;       
    float probability;                  
    float resolution;                   
    unsigned int numDots;               
    bool stopRequested;                 
    float maximumRadius;                
    unsigned int progress;              

    // private static constants
    static const float abohr;           
    static const unsigned int updateSize;         // The amount of dots that have to be calculated before the list of dots is updated and the mutex is locked
};

#endif

---