ChebyshevExpander.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_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