CPropertyExtractor.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_C_PROPERTY_EXTRACTOR
#define COM_DAFER45_TBTK_C_PROPERTY_EXTRACTOR

#include "ChebyshevSolver.h"
#include "Density.h"
#include "Magnetization.h"
#include "LDOS.h"
#include "SpinPolarizedLDOS.h"

#include <iostream>

namespace TBTK{

class CPropertyExtractor{
public:
    CPropertyExtractor(
        ChebyshevSolver *cSolver,
        int numCoefficients,
        int energyResolution,
        bool useGPUToCalculateCoefficients,
        bool useGPUToGenerateGreensFunctions,
        bool useLookupTable = true,
        double lowerBound = -1.,
        double upperBound = 1.
    );

    ~CPropertyExtractor();

    std::complex<double>* calculateGreensFunction(
        Index to,
        Index from,
        ChebyshevSolver::GreensFunctionType type = ChebyshevSolver::GreensFunctionType::Retarded
    );

    std::complex<double>* calculateGreensFunctions(
        std::vector<Index> &to,
        Index from,
        ChebyshevSolver::GreensFunctionType type = ChebyshevSolver::GreensFunctionType::Retarded
    );

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

//  double* calculateDensity(Index pattern, Index ranges);
    Property::Density* calculateDensity(Index pattern, Index ranges);

//  std::complex<double>* calculateMAG(Index pattern, Index ranges);
    Property::Magnetization* calculateMagnetization(
        Index pattern,
        Index ranges
    );

//  double *calculateLDOS(Index pattern, Index ranges);
    Property::LDOS* calculateLDOS(Index pattern, Index ranges);

//  std::complex<double> *calculateSP_LDOS(Index pattern, Index ranges);
    Property::SpinPolarizedLDOS* calculateSpinPolarizedLDOS(
        Index pattern,
        Index ranges
    );
private:
    ChebyshevSolver *cSolver;

    int numCoefficients;

    int energyResolution;

    double lowerBound;

    double upperBound;

    bool useLookupTable;

    bool useGPUToCalculateCoefficients;

    bool useGPUToGenerateGreensFunctions;

    void calculate(
        void (*callback)(
            CPropertyExtractor *cb_this,
            void *memory,
            const Index &index,
            int offset
        ),
        void *memory,
        Index pattern,
        const Index &ranges,
        int currentOffset,
        int offsetMultiplier
    );

    static void calculateDensityCallback(
        CPropertyExtractor *cb_this,
        void *density,
        const Index &index,
        int offset
    );

    static void calculateMAGCallback(
        CPropertyExtractor *cb_this,
        void *density,
        const Index &index,
        int offset
    );

    static void calculateLDOSCallback(
        CPropertyExtractor *cb_this,
        void *ldos,
        const Index &index,
        int offset
    );

    static void calculateSP_LDOSCallback(
        CPropertyExtractor *cb_this,
        void *sp_ldos,
        const Index &index,
        int offset
    );

    void *hint;

    void ensureCompliantRanges(const Index &pattern, Index &ranges);

    void getLoopRanges(
        const Index &pattern,
        const Index &ranges,
        int *lDimensions,
        int **lRanges
    );
};

};  //End of namespace TBTK

#endif