parameters.h

Go to the documentation of this file.

#ifndef PARAMETERS_H
#define PARAMETERS_H

#include <QDateTime>
#include <QFileInfo>
#include <QDebug>
#include <cmath>
#include <QDir>

namespace LangmuirCore
{

struct ConfigurationInfo
{
    QList<qint32> electrons;

    QList<qint32> holes;

    QList<qint32> defects;

    QList<qint32> traps;

    QList<qreal> trapPotentials;

    QList<quint64> fluxInfo;
};

struct SimulationParameters
{
    QString simulationType;

    quint64 randomSeed;

    qint32 gridZ;

    qint32 gridY;

    qint32 gridX;

    bool coulombCarriers;

    qreal coulombGaussianSigma;

    qint32 defectsCharge;

    qint32 outputXyz;

    bool outputXyzE;

    bool outputXyzH;

    bool outputXyzD;

    bool outputXyzT;

    qint32 outputXyzMode;

    bool outputIdsOnDelete;

    qint32 outputCoulomb;

    qint32 outputStepChk;

    bool outputChkTrapPotential;

    bool outputPotential;

    bool outputIsOn;

    bool imageDefects;

    bool imageTraps;

    qint32 imageCarriers;

    qint32 iterationsPrint;

    qint32 iterationsReal;

    qint32 outputPrecision;

    qint32 outputWidth;

    QString outputStub;

    qreal electronPercentage;

    qreal holePercentage;

    qreal seedCharges;

    qreal defectPercentage;

    qreal trapPercentage;

    qreal trapPotential;

    qreal gaussianStdev;

    qreal seedPercentage;

    qreal voltageRight;

    qreal voltageLeft;

    qreal excitonBinding;

    qreal temperatureKelvin;

    qreal sourceRate;

    qreal eSourceLRate;

    qreal eSourceRRate;

    qreal hSourceLRate;

    qreal hSourceRRate;

    qreal generationRate;

    bool balanceCharges;

    qreal drainRate;

    qreal eDrainLRate;

    qreal eDrainRRate;

    qreal hDrainLRate;

    qreal hDrainRRate;

    bool useOpenCL;

    qint32 workX;

    qint32 workY;

    qint32 workZ;

    qint32 workSize;

    qint32 openclThreshold;

    qint32 openclDeviceID;

    qreal boltzmannConstant;

    qreal dielectricConstant;

    qreal elementaryCharge;

    qreal permittivitySpace;

    qreal gridFactor;

    qint32 electrostaticCutoff;

    qreal electrostaticPrefactor;

    qreal inverseKT;

    bool okCL;

    quint32 currentStep;

    QDateTime simulationStart;

    qint32 hoppingRange;

    qreal slopeZ;

    bool sourceMetropolis;

    bool sourceCoulomb;

    qreal recombinationRate;

    qint32 recombinationRange;

    bool outputIdsOnEncounter;

    qreal sourceScaleArea;

    qint32 maxThreads;

    SimulationParameters() :

        simulationType         ("transistor"),
        randomSeed             (0),

        gridZ                  (1),
        gridY                  (128),
        gridX                  (128),

        coulombCarriers        (false),
        coulombGaussianSigma   (0.0),
        defectsCharge          (0),

        outputXyz              (0),
        outputXyzE             (true),
        outputXyzH             (true),
        outputXyzD             (true),
        outputXyzT             (true),
        outputXyzMode          (0),

        outputIdsOnDelete      (false),
        outputCoulomb          (0),
        outputStepChk          (1),
        outputChkTrapPotential (false),
        outputPotential        (false),
        outputIsOn             (true),

        imageDefects           (false),
        imageTraps             (false),
        imageCarriers          (0),

        iterationsPrint        (10),
        iterationsReal         (1000),
        outputPrecision        (15),
        outputWidth            (23),
        outputStub             ("out"),

        electronPercentage     (0.01),
        holePercentage         (0.00),
        seedCharges            (0.00),
        defectPercentage       (0.00),
        trapPercentage         (0.00),
        trapPotential          (0.10),
        gaussianStdev          (0.00),
        seedPercentage         (1.0),

        voltageRight           (0.00),
        voltageLeft            (0.00),
        excitonBinding         (0.00),
        temperatureKelvin      (300.0),

        sourceRate             (0.90),
        eSourceLRate           (-1.0),
        eSourceRRate           (-1.0),
        hSourceLRate           (-1.0),
        hSourceRRate           (-1.0),
        generationRate         (0.001),
        balanceCharges         (false),

        drainRate              (0.90),
        eDrainLRate            (-1.0),
        eDrainRRate            (-1.0),
        hDrainLRate            (-1.0),
        hDrainRRate            (-1.0),

        useOpenCL              (false),
        workX                  (4),
        workY                  (4),
        workZ                  (4),
        workSize               (256),
        openclThreshold        (256),
        openclDeviceID         (0),

        boltzmannConstant      (1.3806504e-23),
        dielectricConstant     (3.5),
        elementaryCharge       (1.60217646e-19),
        permittivitySpace      (8.854187817e-12),
        gridFactor             (1e-9),
        electrostaticCutoff    (50),
        electrostaticPrefactor (0),
        inverseKT              (0),
        okCL                   (false),
        currentStep            (0),
        simulationStart        (QDateTime::currentDateTime()),
        hoppingRange           (1),
        slopeZ                 (0.00),
        sourceMetropolis       (false),
        sourceCoulomb          (false),
        recombinationRate      (0.00),
        recombinationRange     (0),
        outputIdsOnEncounter   (false),
        sourceScaleArea        (65536),
        maxThreads             (-1)
    {
    }

};

inline void setCalculatedValues(SimulationParameters& par)
{
    par.electrostaticPrefactor  = par.elementaryCharge /(4.0 * M_PI * par.dielectricConstant * par.permittivitySpace * par.gridFactor);
    par.inverseKT = par.elementaryCharge /(par.boltzmannConstant * par.temperatureKelvin);
    if (par.outputWidth < 8 ) { par.outputWidth = 8; }
    if (par.outputWidth < (par.outputPrecision + 8)) { par.outputWidth = par.outputPrecision + 8; }
}

inline void checkSimulationParameters(SimulationParameters& par)
{
    setCalculatedValues(par);
    // simulation type
    if (!(QStringList()<<"transistor"<<"solarcell").contains(par.simulationType))
    {
        qFatal("langmuir: simulation.type(%s) must be transistor or solarcell",qPrintable(par.simulationType));
    }

    // grid size
    if (par.gridZ < 1)
    {
        qFatal("langmuir: grid.x(%d) >= 1",par.gridX);
    }
    if (par.gridY < 1)
    {
        qFatal("langmuir: grid.y(%d) >= 1",par.gridY);
    }
    if (par.gridX < 1)
    {
        qFatal("langmuir: grid.z(%d) >= 1",par.gridZ);
    }

    // output
    if (par.iterationsPrint <= 0 )
    {
        qFatal("langmuir: iterations.print(%d) <= 0",par.iterationsPrint);
    }
    if (par.iterationsReal < 0 )
    {
        qFatal("langmuir: iterations.real(%d) < 0",par.iterationsReal);
    }
    if (par.iterationsReal % par.iterationsPrint != 0 )
    {
        qFatal("langmuir: iterations.real(%d) %% iterations.print(%d) != 0",par.iterationsReal,par.iterationsPrint);
    }

    // percentages
    if (par.electronPercentage < 0.0 || par.electronPercentage > 1.0 )
    {
        qFatal("langmuir: electron.pecentage(%f) < 0 || > 1.0",par.electronPercentage);
    }

    if (par.holePercentage     < 0.0 ||par. holePercentage     > 1.0 )
    {
        qFatal("langmuir: hole.pecentage(%f) < 0 || > 1.0",par.holePercentage);
    }

    if (par.defectPercentage   < 0.0 || par.defectPercentage   > 1.0 )
    {
        qFatal("langmuir: defect.pecentage(%f) < 0 || > 1.0",par.defectPercentage);
    }

    if (par.trapPercentage     < 0.0 || par.trapPercentage     > 1.0 )
    {
        qFatal("langmuir: trap.pecentage(%f) < 0 || > 1.0",par.trapPercentage);
    }

    if (par.seedPercentage     < 0.0 || par.seedPercentage     > 1.0 )
    {
        qFatal("langmuir: seed.pecentage(%f) < 0 || > 1.0",par.seedPercentage);
    }

    if (par.defectPercentage > 1.00 - par.trapPercentage)
    {
        qFatal("langmuir: trap.percentage(%f) > 1.0 - trap.percentage(%f)",par.defectPercentage,par.trapPercentage);
    }

    if (par.sourceRate < 0.0 || par.sourceRate > 1.0 )
    {
        qFatal("langmuir: source.rate(%f) < 0 || > 1.0",par.sourceRate);
    }

    if (par.eSourceLRate >= 0.0)
    {
        if (par.eSourceLRate < 0.0 || par.eSourceLRate > 1.0 )
        {
            qFatal("langmuir: e.source.l.rate(%f) < 0 || > 1.0", par.eSourceLRate);
        }
    }

    if (par.eSourceRRate >= 0.0)
    {
        if (par.eSourceRRate < 0.0 || par.eSourceRRate > 1.0 )
        {
            qFatal("langmuir: e.source.r.rate(%f) < 0 || > 1.0", par.eSourceRRate);
        }
    }

    if (par.hSourceLRate >= 0.0)
    {
        if (par.hSourceLRate < 0.0 || par.hSourceLRate > 1.0 )
        {
            qFatal("langmuir: h.source.l.rate(%f) < 0 || > 1.0", par.hSourceLRate);
        }
    }

    if (par.hSourceRRate >= 0.0)
    {
        if (par.hSourceRRate < 0.0 || par.hSourceRRate > 1.0 )
        {
            qFatal("langmuir: h.source.r.rate(%f) < 0 || > 1.0", par.hSourceRRate);
        }
    }

    if (par.generationRate >= 0.0)
    {
        if (par.generationRate < 0.0 || par.generationRate > 1.0 )
        {
            qFatal("langmuir: x.source.rate(%f) < 0 || > 1.0", par.generationRate);
        }
    }

    if (par.drainRate < 0.0 || par.drainRate > 1.0 )
    {
        qFatal("langmuir: drain.rate(%f) < 0 || > 1.0",par.drainRate);
    }

    if (par.eDrainLRate >= 0.0)
    {
        if (par.eDrainLRate < 0.0 || par.eDrainLRate > 1.0 )
        {
            qFatal("langmuir: e.drain.l.rate(%f) < 0 || > 1.0", par.eDrainLRate);
        }
    }

    if (par.eDrainRRate >= 0.0)
    {
        if (par.eDrainRRate < 0.0 || par.eDrainRRate > 1.0 )
        {
            qFatal("langmuir: e.drain.r.rate(%f) < 0 || > 1.0", par.eDrainRRate);
        }
    }

    if (par.hDrainLRate >= 0.0)
    {
        if (par.hDrainLRate < 0.0 || par.hDrainLRate > 1.0 )
        {
            qFatal("langmuir: h.drain.l.rate(%f) < 0 || > 1.0", par.hDrainLRate);
        }
    }

    if (par.hDrainRRate >= 0.0)
    {
        if (par.hDrainRRate < 0.0 || par.hDrainRRate > 1.0 )
        {
            qFatal("langmuir: h.drain.r.rate(%f) < 0 || > 1.0", par.hDrainRRate);
        }
    }

    if (par.seedCharges < 0.0 || par.seedCharges > 1.0 )
    {
        qFatal("langmuir: seed.charges(%f) < 0 || > 1.0",par.seedCharges);
    }

    // other
    if (par.gaussianStdev < 0.00)
    {
        qFatal("langmuir: gaussian.stdev < 0.0");
    }
    if (par.temperatureKelvin < 0.0)
    {
        qFatal("langmuir: temperature.kelvin < 0.0");
    }

    if (par.defectsCharge != 0 && ! par.coulombCarriers)
    {
        qFatal("langmuir: defects.charge != 0 && coulomb.carriers = false");
    }

    if (par.hoppingRange < 0 || par.hoppingRange > 2)
    {
        qFatal("langmuir: hopping.range(%d) < 0 || > 2",par.hoppingRange);
    }

    if (!par.sourceMetropolis)
    {
        if (par.sourceCoulomb)
        {
            qFatal("langmuir: source.metropolis = false, yet source.coulomb = true");
        }
    }

    if (par.recombinationRate < 0.0 || par.recombinationRate > 1.0 )
    {
        qFatal("langmuir: recombination.rate(%f) < 0 || > 1.0",par.recombinationRate);
    }

    if (par.recombinationRate > 0 && par.simulationType != "solarcell")
    {
        qFatal("langmuir: recombination.rate(%f) > 0, yet simulation.type != solarcell",par.recombinationRate);
    }

    if (par.recombinationRate && !((par.electronPercentage > 0) && (par.holePercentage > 0)))
    {
        qFatal("langmuir: recombination.rate(%f) > 0, yet electron.percentage = %.5f and hole.percentage = %.5f",
               par.recombinationRate, par.electronPercentage, par.holePercentage);
    }

    if (par.outputIdsOnEncounter && (par.simulationType != "solarcell"))
    {
        qFatal("langmuir: output.ids.on.encounter == true, yet simulation.type != solarcell");
    }

    if (par.outputIdsOnEncounter && !((par.electronPercentage > 0) && (par.holePercentage > 0)))
    {
        qFatal("langmuir: output.ids.on.encounter == true, yet electron.percentage = %.5f and hole.percentage = %.5f",
               par.electronPercentage, par.holePercentage);
    }

    if (((par.outputXyzE == false) && (par.outputXyzH == false) && (par.outputXyzD == false) && (par.outputXyzT == false)) && par.outputXyz > 0)
    {
        qFatal("langmuir: output.xyz > 0, yet output.xyz.e && output.xyz.h && output.xyz.d && output.xyz.t are all false");

    }

    if (par.outputXyzMode < 0 || par.outputXyzMode > 1)
    {
        qFatal("langmuir: output.xyz.mode must be 0 or 1");
    }

    if (par.openclThreshold <= 0)
    {
        qFatal("langmuir: opencl.threshold must be >= 0");
    }

    if (par.openclDeviceID < 0)
    {
        qFatal("langmuir: opencl.device.id must be >= 0");
    }

    if (par.balanceCharges && par.simulationType != "solarcell")
    {
        qFatal("langmuir: balance.charges == true, yet simulation.type != solarcell");
    }

    if (par.coulombGaussianSigma > 0)
    {
        if (par.gridX == 1 || par.gridY == 1 || par.gridZ == 1)
        {
            qFatal("langmuir: coulomb.gaussian.sigma > 0, yet the simulation is not 3D");
        }
        if(qMin(qMin(par.gridX, par.gridY), par.gridZ)
                < 3 * par.coulombGaussianSigma)
        {
            qDebug("langmuir: 3 * coulomb.gaussian.sigma <= qMin(grid.x, grid.y, grid.z)");
        }
    }

    if (par.outputIdsOnEncounter)
    {
        qFatal("langmuir: output.ids.on.encouter is deprecated");
    }
}

}

#endif // PARAMETERS_H