ChebyshevSolver.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_CHEBYSHEV_SOLVER
#define COM_DAFER45_TBTK_CHEBYSHEV_SOLVER

#include "Model.h"
#include <complex>
#include <omp.h>

namespace TBTK{

class ChebyshevSolver{
public:
    ChebyshevSolver();

    ~ChebyshevSolver();

    void setModel(Model *model);

    Model* getModel();

    void setScaleFactor(double scaleFactor);

    double getScaleFactor();

    void calculateCoefficients(
        std::vector<Index> &to,
        Index from,
        std::complex<double> *coefficients,
        int numCoefficients,
        double broadening = 0.0001
    );

    void calculateCoefficients(
        Index to,
        Index from,
        std::complex<double> *coefficients,
        int numCoefficients,
        double broadening = 0.0001
    );

    void calculateCoefficientsGPU(
        std::vector<Index> &to,
        Index from,
        std::complex<double> *coefficients,
        int numCoefficients,
        double broadening = 0.0001
    );

    void calculateCoefficientsGPU(
        Index to,
        Index from,
        std::complex<double> *coefficients,
        int numCoefficients,
        double broadening = 0.0001
    );

    void calculateCoefficientsWithCutoff(
        Index to,
        Index from,
        std::complex<double> *coefficients,
        int numCoefficients,
        double componentCutoff,
        double broadening = 0.0001
    );

    void generateLookupTable(
        int numCoefficeints,
        int energyResolution,
        double lowerBound = -1.,
        double upperBound = 1.
    );

    void loadLookupTableGPU();

    void destroyLookupTableGPU();

    enum class GreensFunctionType{
        Advanced,
        Retarded,
        Principal,
        NonPrincipal
    };

    void generateGreensFunction(
        std::complex<double> *greensFunction,
        std::complex<double> *coefficients,
        int numCoefficients,
        int energyResolution,
        double lowerBound = -1.,
        double upperBound = 1.,
        GreensFunctionType type = GreensFunctionType::Retarded
    );

    void generateGreensFunction(
        std::complex<double> *greensFunction,
        std::complex<double> *coefficients,
        GreensFunctionType type = GreensFunctionType::Retarded
    );

    void generateGreensFunctionGPU(
        std::complex<double> *greensFunction,
        std::complex<double> *coefficients,
        GreensFunctionType type = GreensFunctionType::Retarded
    );

    std::complex<double> getMonolopoulosABCDamping(
        double distanceToEdge,
        double boundarySize,
        double e = 1.,
        double c = 2.62
    );

    void setDamping(std::complex<double> *damping);

    void setTalkative(bool isTalkative);
private:
    Model *model;

    double scaleFactor;

    std::complex<double> *damping;

    std::complex<double> **generatingFunctionLookupTable;

    std::complex<double> ***generatingFunctionLookupTable_device;

    int lookupTableNumCoefficients;

    int lookupTableResolution;

    bool isTalkative;

//  static int numChebyshevSolvers;

//  static int numDevices;

//  static bool *busyDevices;

//  static omp_lock_t busyDevicesLock;

//  static void createDeviceTableGPU();

//  static void destroyDeviceTableGPU();

//  static int allocateDeviceGPU();

//  static void freeDeviceGPU(int device);

/*  static class StaticConstructor{
    public:
        StaticConstructor();
    } staticConstructor;*/
};

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

inline void ChebyshevSolver::setScaleFactor(double scaleFactor){
    this->scaleFactor = scaleFactor;
}

inline double ChebyshevSolver::getScaleFactor(){
    return scaleFactor;
}

inline void ChebyshevSolver::setDamping(std::complex<double> *damping){
    this->damping = damping;
}

inline void ChebyshevSolver::setTalkative(bool isTalkative){
    this->isTalkative = isTalkative;
}

};  //End of namespace TBTK

#endif