ChebyshevExpander.h

/* 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_SOLVER_CHEBYSHEV_EXPANDER
#define COM_DAFER45_TBTK_SOLVER_CHEBYSHEV_EXPANDER

#include "TBTK/Communicator.h"
#include "TBTK/Model.h"
#include "TBTK/Solver/Solver.h"

#include <complex>
#ifndef __APPLE__
#   include <omp.h>
#endif

namespace TBTK{
namespace Solver{

class ChebyshevExpander : public Solver, public Communicator{
public:
    ChebyshevExpander();

    virtual ~ChebyshevExpander();

//  virtual void setModel(Model &model);

    void setScaleFactor(double scaleFactor);

    double getScaleFactor();

    void setNumCoefficients(int numCoefficients);

    int getNumCoefficients() const;

    void setBroadening(double broadening);

    double getBroadening() const;

    void setEnergyResolution(int energyResolution);

    int getEnergyResolution() const;

    void setLowerBound(double lowerBound);

    double getLowerBound() const;

    void setUpperBound(double upperBound);

    double getUpperBound() const;

    void setCalculateCoefficientsOnGPU(bool calculateCoefficientsOnGPU);

    bool getCalculateCoefficientsOnGPU() const;

    void setGenerateGreensFunctionsOnGPU(
        bool generateGreensFunctionsOnGPU
    );

    bool getGenerateGreensFunctionsOnGPU() const;

    void setUseLookupTable(bool useLookupTable);

    bool getUseLookupTable() const ;

    std::vector<std::vector<std::complex<double>>> calculateCoefficients(
        std::vector<Index> &to,
        Index from
    );

    std::vector<std::complex<double>> calculateCoefficients(
        Index to,
        Index from
    );

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

    std::vector<std::complex<double>> generateGreensFunction(
        const std::vector<std::complex<double>> &coefficients,
        Type type = Type::Retarded
    );
private:
    //These three functions are experimental and therefore not part of the
    //public interface of released code.

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

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

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

    int numCoefficients;

    double broadening;

    int energyResolution;

    double lowerBound;

    double upperBound;

    bool calculateCoefficientsOnGPU;

    bool generateGreensFunctionsOnGPU;

    bool useLookupTable;

    std::complex<double> *damping;

    std::complex<double> **generatingFunctionLookupTable;

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

    int lookupTableNumCoefficients;

    int lookupTableResolution;

    double lookupTableLowerBound;

    double lookupTableUpperBound;

    void ensureLookupTableIsReady();

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

    void destroyLookupTable();

    bool getLookupTableIsGenerated();

    void loadLookupTableGPU();

    void destroyLookupTableGPU();

    bool getLookupTableIsLoadedGPU();

    std::vector<
        std::vector<std::complex<double>>
    > calculateCoefficientsCPU(
        std::vector<Index> &to,
        Index from
    );

    std::vector<std::complex<double>> calculateCoefficientsCPU(
        Index to,
        Index from
    );

    std::vector<
        std::vector<std::complex<double>>
    > calculateCoefficientsGPU(
        std::vector<Index> &to,
        Index from
    );

    std::vector<std::complex<double>> calculateCoefficientsGPU(
        Index to,
        Index from
    );

/*  std::complex<double>* generateGreensFunctionCPU(
        std::complex<double> *coefficients,
        int numCoefficients,
        int energyResolution,
        double lowerBound = -1.,
        double upperBound = 1.,
        Type type = Type::Retarded
    );*/

    std::vector<std::complex<double>> generateGreensFunctionCPU(
        const std::vector<std::complex<double>> &coefficients,
        Type type = Type::Retarded
    );

    std::vector<std::complex<double>> generateGreensFunctionGPU(
        const std::vector<std::complex<double>> &coefficients,
        Type type = Type::Retarded
    );
};

inline void ChebyshevExpander::setScaleFactor(double scaleFactor){
    if(generatingFunctionLookupTable != nullptr)
        destroyLookupTable();
    if(generatingFunctionLookupTable_device != nullptr)
        destroyLookupTableGPU();

    this->scaleFactor = scaleFactor;
}

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

inline void ChebyshevExpander::setNumCoefficients(int numCoefficients){
    if(generatingFunctionLookupTable != nullptr)
        destroyLookupTable();
    if(generatingFunctionLookupTable_device != nullptr)
        destroyLookupTableGPU();

    this->numCoefficients = numCoefficients;
}

inline int ChebyshevExpander::getNumCoefficients() const{
    return numCoefficients;
}

inline void ChebyshevExpander::setBroadening(double broadening){
    this->broadening = broadening;
}

inline double ChebyshevExpander::getBroadening() const{
    return broadening;
}

inline void ChebyshevExpander::setEnergyResolution(int energyResolution){
    if(generatingFunctionLookupTable != nullptr)
        destroyLookupTable();
    if(generatingFunctionLookupTable_device != nullptr)
        destroyLookupTableGPU();

    this->energyResolution = energyResolution;
}

inline int ChebyshevExpander::getEnergyResolution() const{
    return energyResolution;
}

inline void ChebyshevExpander::setLowerBound(double lowerBound){
    if(generatingFunctionLookupTable != nullptr)
        destroyLookupTable();
    if(generatingFunctionLookupTable_device != nullptr)
        destroyLookupTableGPU();

    this->lowerBound = lowerBound;
}

inline double ChebyshevExpander::getLowerBound() const{
    return lowerBound;
}

inline void ChebyshevExpander::setUpperBound(double upperBound){
    if(generatingFunctionLookupTable != nullptr)
        destroyLookupTable();
    if(generatingFunctionLookupTable_device != nullptr)
        destroyLookupTableGPU();

    this->upperBound = upperBound;
}

inline double ChebyshevExpander::getUpperBound() const{
    return upperBound;
}

inline void ChebyshevExpander::setCalculateCoefficientsOnGPU(
    bool calculateCoefficientsOnGPU
){
    this->calculateCoefficientsOnGPU = calculateCoefficientsOnGPU;
}

inline bool ChebyshevExpander::getCalculateCoefficientsOnGPU() const{
    return calculateCoefficientsOnGPU;
}

inline void ChebyshevExpander::setGenerateGreensFunctionsOnGPU(
    bool generateGreensFunctionsOnGPU
){
    this->generateGreensFunctionsOnGPU = generateGreensFunctionsOnGPU;
}

inline bool ChebyshevExpander::getGenerateGreensFunctionsOnGPU() const{
    return generateGreensFunctionsOnGPU;
}

inline void ChebyshevExpander::setUseLookupTable(bool useLookupTable){
    if(!useLookupTable){
        if(generatingFunctionLookupTable != nullptr)
            destroyLookupTable();
        if(generatingFunctionLookupTable_device != nullptr)
            destroyLookupTableGPU();
    }

    this->useLookupTable = useLookupTable;
}

inline bool ChebyshevExpander::getUseLookupTable() const{
    return useLookupTable;
}

inline std::vector<
        std::vector<std::complex<double>>
> ChebyshevExpander::calculateCoefficients(
    std::vector<Index> &to,
    Index from
){
    if(calculateCoefficientsOnGPU){
        return calculateCoefficientsGPU(
            to,
            from
        );
    }
    else{
        return calculateCoefficientsCPU(
            to,
            from
        );
    }
}

inline std::vector<std::complex<double>> ChebyshevExpander::calculateCoefficients(
    Index to,
    Index from
){
    if(calculateCoefficientsOnGPU){
        return calculateCoefficientsGPU(
            to,
            from
        );
    }
    else{
        return calculateCoefficientsCPU(
            to,
            from
        );
    }
}

inline bool ChebyshevExpander::getLookupTableIsGenerated(){
    if(generatingFunctionLookupTable != NULL)
        return true;
    else
        return false;
}

inline bool ChebyshevExpander::getLookupTableIsLoadedGPU(){
    if(generatingFunctionLookupTable_device != NULL)
        return true;
    else
        return false;
}

inline std::vector<std::complex<double>> ChebyshevExpander::generateGreensFunction(
    const std::vector<std::complex<double>> &coefficients,
    Type type
){
    if(generateGreensFunctionsOnGPU){
        return generateGreensFunctionGPU(coefficients, type);
    }
    else{
        return generateGreensFunctionCPU(coefficients, type);
    }
}

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

inline void ChebyshevExpander::ensureLookupTableIsReady(){
    if(useLookupTable){
        if(!generatingFunctionLookupTable)
            generateLookupTable(numCoefficients, energyResolution, lowerBound, upperBound);
        if(generateGreensFunctionsOnGPU && !generatingFunctionLookupTable_device)
            loadLookupTableGPU();
    }
    else if(generateGreensFunctionsOnGPU){
        TBTKExit(
            "Solver::ChebyshevSolver::ensureLookupTableIsReady()",
            "Green's functions can only be generated on GPU using"
            << " lookup tables.",
            "Use Solver::ChebyshevExpander::setGenerateGreensFunctionOnGPU()"
            << " and"
            << " Solver::ChebyshevExpander::setUseLookupTable() to"
            << " configure the Solver::ChebyshevExpander."
        );
    }
}

};  //End of namespace Solver
};  //End of namespace TBTK

#endif