TimeEvolver.h

Go to the documentation of this file.

/* Copyright 2016 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef COM_DAFER45_TBTK_TIME_EVOLVER
#define COM_DAFER45_TBTK_TIME_EVOLVER

#include "Model.h"
#include "DiagonalizationSolver.h"
#include "UnitHandler.h"
#include <vector>
#include <complex>

namespace TBTK{

class TimeEvolver{
public:
    TimeEvolver(TBTK::Model *model);

    ~TimeEvolver();

    void run();

    void setCallback(bool (*callback)(TimeEvolver *timeEvolver));

    void setMaxSCIterations(int maxIterations);

    void setNumTimeSteps(int numTimeSteps);

    void setTimeStep(double dt);

    void setNumberOfParticles(int numberOfParticles);

    int getNumberOfParticles();

    void fixParticleNumber(bool particleNumberIsFixed);

    double getOccupancy(int state);

    DiagonalizationSolver *getDiagonalizationSolver();

    double getEigenValue(int state);

    const std::complex<double> getAmplitude(int state, const Index &index);

    Model* getModel();

    enum class DecayMode{None, Instantly, Interpolate, Custom};

    void setDecayMode(DecayMode decayMode);

    class DecayHandler{
    public:
        virtual void decay(
            TimeEvolver *timeEvolver,
            double *occupancy,
            double *eigenValues,
            std::complex<double> **eigenVectorsMap
        ) = 0;
    private:
    };

    void setDecayHandler(DecayHandler *decayHandler);

    int getCurrentTimeStep();

    void setOrthogonalityCheckInterval(int orthogonalityCheckInterval);

    double getOrthogonalityError();
private:
    Model *model;

    DiagonalizationSolver dSolver;

    double *eigenValues;

    std::complex<double> *eigenVectors;

    std::complex<double> **eigenVectorsMap;

    double* occupancy;

    int numberOfParticles;

    bool particleNumberIsFixed;

    DecayMode decayMode;

    DecayHandler *decayHandler;

    bool (*callback)(TimeEvolver *timeEvolver);

    int numTimeSteps;

    double dt;

    int currentTimeStep;

    static std::vector<TimeEvolver*> timeEvolvers;

    static std::vector<DiagonalizationSolver*> dSolvers;

    static bool scCallback(DiagonalizationSolver *dSolver);

    void onDiagonalizationFinished();

    void sort();

    void updateOccupancy();

    void decayInstantly();

    void decayInterpolate();

    double orthogonalityError;

    int orthogonalityCheckInterval;

    void calculateOrthogonalityError();
};

inline void TimeEvolver::setCallback(
    bool (*callback)(TimeEvolver *timeEvolver)
){
    this->callback = callback;
}

inline void TimeEvolver::setMaxSCIterations(int maxIterations){
    dSolver.setMaxIterations(maxIterations);
}

inline void TimeEvolver::setNumTimeSteps(int numTimeSteps){
    this->numTimeSteps = numTimeSteps;
}

inline void TimeEvolver::setTimeStep(double dt){
    this->dt = dt;
}

inline void TimeEvolver::setNumberOfParticles(int numberOfParticles){
    this->numberOfParticles = numberOfParticles;
}

inline int TimeEvolver::getNumberOfParticles(){
    return numberOfParticles;
}

inline void TimeEvolver::fixParticleNumber(bool particleNumberIsFixed){
    this->particleNumberIsFixed = particleNumberIsFixed;
}

inline DiagonalizationSolver* TimeEvolver::getDiagonalizationSolver(){
    return &dSolver;
}

inline double TimeEvolver::getEigenValue(int state){
    return eigenValues[state];
}

inline double TimeEvolver::getOccupancy(int state){
    return occupancy[state];
}

inline const std::complex<double> TimeEvolver::getAmplitude(
    int state,
    const Index &index
){
    return eigenVectorsMap[state][model->getBasisIndex(index)];
}

inline Model* TimeEvolver::getModel(){
    return model;
}

inline void TimeEvolver::setDecayMode(DecayMode decayMode){
    this->decayMode = decayMode;
}

inline void TimeEvolver::setDecayHandler(DecayHandler *decayHandler){
    this->decayHandler = decayHandler;
}

inline int TimeEvolver::getCurrentTimeStep(){
    return currentTimeStep;
}

inline void TimeEvolver::setOrthogonalityCheckInterval(
    int orthogonalityCheckInterval
){
    this->orthogonalityCheckInterval = orthogonalityCheckInterval;
}

inline double TimeEvolver::getOrthogonalityError(){
    return orthogonalityError;
}

}; //End of namespace TBTK

#endif