DPropertyExtractor.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_D_PROPERTY_EXTRACTOR
#define COM_DAFER45_TBTK_D_PROPERTY_EXTRACTOR

#include "DiagonalizationSolver.h"
#include "EigenValues.h"
#include "DOS.h"
#include "Density.h"
#include "Magnetization.h"
#include "SpinPolarizedLDOS.h"

#include <complex>

namespace TBTK{

class DPropertyExtractor{
public:
    DPropertyExtractor(DiagonalizationSolver *dSolver);

    ~DPropertyExtractor();

    void saveEigenValues(
        std::string path = "./",
        std::string filename = "EV.dat"
    );

    void getTabulatedAmplitudeSet(
        std::complex<double> **amplitudes,
        int **indices,
        int *numHoppingAmplitudes,
        int *maxIndexSize
    );

//  double* getEigenValues();
    Property::EigenValues* getEigenValues();

    double getEigenValue(int state);

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

//  double* calculateDOS(double l_lim, double u_lim, int resolution);
    Property::DOS* calculateDOS(
        double l_lim,
        double u_lim,
        int resolution
    );

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

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

//  double* calculateSP_LDOS(Index pattern, Index ranges, double u_lim, double l_lim, int resolution);
//  std::complex<double>* calculateSP_LDOS(Index pattern, Index ranges, double l_lim, double u_lim, int resolution);
    Property::SpinPolarizedLDOS* calculateSpinPolarizedLDOS(
        Index pattern,
        Index ranges,
        double l_lim,
        double u_lim,
        int resolution
    );

/*  void save(int *memory, int size, int columns, std::string filename, std::string path = "./");
    void save(double *memory, int size, int columns, std::string filename, std::string path = "./");
    void save(std::complex<double> *memory, int size, int columns, std::string filename, std::string path = "./");
    void save2D(int *memory, int size_x, int size_y, int columns, std::string filename, std::string path = "./");
    void save2D(double *memory, int size_x, int size_y, int columns, std::string filename, std::string path = "./");
    void save2D(std::complex<double> *memory, int size_x, int size_y, int columns, std::string filename, std::string path = "./");*/
private:
    void calculate(
        void (*callback)(
            DPropertyExtractor *cb_this,
            void *memory,
            const Index &index,
            int offset
        ),
        void *memory,
        Index pattern,
        const Index &ranges,
        int currentOffset,
        int offsetMultiplier
    );

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

    static void calculateMAGCallback(
        DPropertyExtractor *cb_this,
        void *mag,
        const Index &index,
        int offset
    );

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

    DiagonalizationSolver *dSolver;

    void *hint;

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

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

inline double DPropertyExtractor::getEigenValue(int state){
    return dSolver->getEigenValue(state);
}

inline const std::complex<double> DPropertyExtractor::getAmplitude(
    int state,
    const Index &index
){
    return dSolver->getAmplitude(state, index);
}

};  //End of namespace TBTK

#endif