world.h

Go to the documentation of this file.

#ifndef WORLD_H
#define WORLD_H
#define BOOST_DISABLE_ASSERTS

#include <QtCore>
#include <QtGui>

#ifndef Q_MOC_RUN

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#pragma GCC diagnostic push
#pragma GCC system_header
#endif

#include "boost/multi_array.hpp"

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#pragma GCC diagnostic pop
#endif

#endif

namespace LangmuirCore
{

class Grid;
class Agent;
class Random;
class Logger;
class KeyValueParser;
class Potential;
class FluxAgent;
class DrainAgent;
class HoleDrainAgent;
class ElectronDrainAgent;
class RecombinationAgent;
class Simulation;
class ChargeAgent;
class SourceAgent;
class HoleSourceAgent;
class ExcitonSourceAgent;
class ElectronSourceAgent;
class CheckPointer;
class OpenClHelper;
struct SimulationParameters;
struct ConfigurationInfo;

class World : public QObject
{
private:
    Q_OBJECT
    Q_DISABLE_COPY(World)

public:
    World(const QString& fileName, int cores=-1, int gpuID=-1, QObject *parent = 0);
    World(SimulationParameters &parameters, int cores=-1, int gpuID=-1, QObject *parent = 0);
    World(SimulationParameters &parameters, ConfigurationInfo &configInfo, int cores=-1, int gpuID=-1, QObject *parent = 0);

    ~World();

    KeyValueParser& keyValueParser();

    CheckPointer& checkPointer();

    Grid& electronGrid();

    Grid& holeGrid();

    Potential& potential();

    SimulationParameters& parameters();

    Random& randomNumberGenerator();

    Logger& logger();

    OpenClHelper& opencl();

    QList<SourceAgent*>& sources();

    QList<SourceAgent*>& eSources();

    QList<SourceAgent*>& hSources();

    QList<SourceAgent*>& xSources();

    QList<DrainAgent*>& drains();

    QList<DrainAgent*>& eDrains();

    QList<DrainAgent*>& hDrains();

    QList<DrainAgent*>& xDrains();

    QList<FluxAgent*>& fluxes();

    ElectronSourceAgent& electronSourceAgentRight();

    ElectronSourceAgent& electronSourceAgentLeft();

    HoleSourceAgent& holeSourceAgentRight();

    HoleSourceAgent& holeSourceAgentLeft();

    ExcitonSourceAgent& excitonSourceAgent();

    ElectronDrainAgent& electronDrainAgentRight();

    ElectronDrainAgent& electronDrainAgentLeft();

    HoleDrainAgent& holeDrainAgentRight();

    HoleDrainAgent& holeDrainAgentLeft();

    RecombinationAgent& recombinationAgent();

    QList<ChargeAgent*>& electrons();

    QList<ChargeAgent*>& holes();

    QList<int>& defectSiteIDs();

    QList<int>& trapSiteIDs();

    QList<double>& trapSitePotentials();

    boost::multi_array<double,3>& R1();

    boost::multi_array<double,3>& R2();

    boost::multi_array<double,3>& iR();

    boost::multi_array<double,3>& eR();

    boost::multi_array<double, 3>& sI();

    boost::multi_array<double,3>& couplingConstants();

    int maxElectronAgents();

    int maxHoleAgents();

    int maxChargeAgents();

    int maxChargeAgentsAndChargedDefects();

    int maxDefects();

    int maxTraps();

    int numElectronAgents();

    int numHoleAgents();

    int numChargeAgents();

    int electronsMinusHoles();

    int holesMinusElectrons();

    bool chargesAreBalanced();

    int numChargeAgentsAndChargedDefects();

    int numDefects();

    int numTraps();

    double reachedChargeAgents();

    double reachedElectronAgents();

    double reachedHoleAgents();

    double percentHoleAgents();

    double percentElectronAgents();

    bool atMaxElectrons();

    bool atMaxHoles();

    bool atMaxCharges();

private:
    KeyValueParser *m_keyValueParser;

    CheckPointer *m_checkPointer;

    QList<SourceAgent*> m_sources;

    QList<SourceAgent*> m_eSources;

    QList<SourceAgent*> m_hSources;

    QList<SourceAgent*> m_xSources;

    QList<DrainAgent*> m_drains;

    QList<DrainAgent*> m_eDrains;

    QList<DrainAgent*> m_hDrains;

    QList<DrainAgent*> m_xDrains;

    QList<FluxAgent*> m_fluxAgents;

    ElectronSourceAgent *m_electronSourceAgentRight;

    ElectronSourceAgent *m_electronSourceAgentLeft;

    HoleSourceAgent *m_holeSourceAgentRight;

    HoleSourceAgent *m_holeSourceAgentLeft;

    ExcitonSourceAgent *m_excitonSourceAgent;

    ElectronDrainAgent *m_electronDrainAgentRight;

    ElectronDrainAgent *m_electronDrainAgentLeft;

    HoleDrainAgent *m_holeDrainAgentRight;

    HoleDrainAgent *m_holeDrainAgentLeft;

    RecombinationAgent *m_recombinationAgent;

    Grid *m_electronGrid;

    Grid *m_holeGrid;

    Random *m_rand;

    Potential *m_potential;

    SimulationParameters *m_parameters;

    Logger *m_logger;

    OpenClHelper *m_ocl;

    QList<ChargeAgent*> m_electrons;

    QList<ChargeAgent*> m_holes;

    QList<int> m_defectSiteIDs;

    QList<int> m_trapSiteIDs;

    QList<double> m_trapSitePotentials;

    boost::multi_array<double,3> m_R2;

    boost::multi_array<double,3> m_R1;

    boost::multi_array<double,3> m_iR;

    boost::multi_array<double,3> m_eR;

    boost::multi_array<double, 3> m_sI;

    boost::multi_array<double,3> m_couplingConstants;

    int m_maxElectrons;

    int m_maxHoles;

    int m_maxDefects;

    int m_maxTraps;

    void placeDefects(const QList<int>& siteIDs = QList<int>());

    void placeElectrons(const QList<int>& siteIDs = QList<int>());

    void placeHoles(const QList<int>& siteIDs = QList<int>());

    void createSources();

    void createDrains();

    void setFluxInfo(const QList<quint64> &fluxInfo);

    void alterMaxThreads(int cores = -1);

    void initialize(const QString& fileName = "", SimulationParameters *pparameters = NULL, ConfigurationInfo *pconfigInfo = NULL,
        int cores = -1, int gpuID = -1);
};

}
#endif // WORLD_H