Plotter.h

Go to the documentation of this file.

/* Copyright 2019 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_VISUALIZATION_MAT_PLOT_LIB_PLOTTER
#define COM_DAFER45_TBTK_VISUALIZATION_MAT_PLOT_LIB_PLOTTER
 
#include "TBTK/AnnotatedArray.h"
#include "TBTK/Array.h"
#include "TBTK/Property/Density.h"
#include "TBTK/Property/DOS.h"
#include "TBTK/Property/EigenValues.h"
#include "TBTK/Property/LDOS.h"
#include "TBTK/Property/Magnetization.h"
#include "TBTK/Property/SpinPolarizedLDOS.h"
#include "TBTK/Property/WaveFunctions.h"
#include "TBTK/Streams.h"
#include "TBTK/TBTKMacros.h"
#include "TBTK/Visualization/MatPlotLib/Argument.h"
#include "TBTK/Visualization/MatPlotLib/ContourfParameters.h"
#include "TBTK/Visualization/MatPlotLib/matplotlibcpp.h"
#include "TBTK/Visualization/MatPlotLib/PlotParameters.h"
#include "TBTK/Visualization/MatPlotLib/PlotSurfaceParameters.h"
 
#include <string>
#include <tuple>
#include <vector>
 
 
namespace TBTK{
namespace Visualization{
namespace MatPlotLib{
 
class Plotter{
public:
    Plotter();
 
    void setSize(unsigned int width, unsigned int height);
 
    void setBoundsX(double minX, double maxX);
 
    void setBoundsY(double minY, double maxY);
 
    void setBounds(double minX, double maxX, double minY, double maxY);
 
//  void setAutoScaleX(bool autoScaleX);
 
//  void setAutoScaleY(bool autoScaleY);
 
//  void setAutoScale(bool autoScale);
 
    void setAxes(
        const std::vector<
            std::pair<unsigned int, std::vector<double>>
        > &axes
    );
 
    void setTitle(const std::string &title, bool overwrite = true);
 
    void setLabelX(const std::string &labelX, bool overwrite = true);
 
    void setLabelY(const std::string &labelY, bool overwrite = true);
 
    void setLabelZ(const std::string &labelZ, bool overwrite = true);
 
//  void plot(double x, double y, const std::string &arguments);
 
    void plot(
        const Property::Density &density,
        const Argument &argument = ""
    );
 
    void plot(
        const Index &pattern,
        const Property::Density &density,
        const Argument &argument = ""
    );
 
    void plot(
        const Property::DOS &dos,
        const Argument &argument = ""
    );
 
    void plot(
        const Property::EigenValues &eigenValues,
        const Argument &argument = "black"
    );
 
    void plot(const Property::LDOS &ldos, const Argument &argument = "");
 
    void plot(
        const Index &pattern,
        const Property::LDOS &ldos,
        const Argument &argument = ""
    );
 
    void plot(
        const Vector3d &direction,
        const Property::Magnetization &magnetization,
        const Argument &argument = ""
    );
 
    void plot(
        const Index &pattern,
        const Vector3d &direction,
        const Property::Magnetization &magnetization,
        const Argument &argument = ""
    );
 
    void plot(
        const Vector3d &direction,
        const Property::SpinPolarizedLDOS &spinPolarizedLDOS,
        const Argument &argument = ""
    );
 
    void plot(
        const Index &pattern,
        const Vector3d &direction,
        const Property::SpinPolarizedLDOS &spinPolarizedLDOS,
        const Argument &argument = ""
    );
 
    void plot(
        unsigned int state,
        const Property::WaveFunctions &waveFunctions,
        const Argument &argument = ""
    );
 
    void plot(
        const Index &pattern,
        unsigned int state,
        const Property::WaveFunctions &waveFunctions,
        const Argument &argument = ""
    );
 
    void plot(
        const AnnotatedArray<double, double> &data,
        const Argument &argument = ""
    );
 
    void plot(
        const AnnotatedArray<double, Subindex> &data,
        const Argument &argument = ""
    );
 
    void plot(const Array<double> &data, const Argument &argument = "");
 
    void plot(
        Array<double> x,
        const Array<double> &y,
        const Argument &argument = ""
    );
 
    void plot(
        Array<double> x,
        Array<double> y,
        const Array<double> &z,
        const Argument &argument = ""
    );
 
/*  void plot(
        const std::vector<std::vector<double>> &data,
        const std::vector<std::vector<double>> &intensity,
        const std::string &arguments
    );*/
 
/*  void plot(
        const Array<double> &data,
        const Array<double> &intensity,
        const std::string &arguments
    );*/
 
    void setPlotMethod3D(const std::string &plotMethod3D);
 
    void setRotation(int elevation, int azimuthal, bool overwrite = true);
 
    void setNumContours(unsigned int numContours);
 
//  void setHold(bool hold);
 
    void clear();
 
    void show() const;
 
    void save(const std::string &filename) const;
 
    void plot(
        const Array<double> &data,
        const std::initializer_list<
            std::pair<std::string, std::string>
        > &argument
    ){
        plot(data, Argument(argument));
    }
 
    void plot(
        const std::initializer_list<double> &data,
        const Argument &argument = ""
    ){
        plot(std::vector<double>(data), argument);
    }
 
    void plot(
        const std::initializer_list<double> &x,
        const Array<double> &y,
        const Argument &argument = ""
    ){
        plot(std::vector<double>(x), y, argument);
    }
 
    void plot(
        const Array<double> &x,
        const std::initializer_list<double> &y,
        const Argument &argument = ""
    ){
        plot(x, std::vector<double>(y), argument);
    }
 
    void plot(
        const std::initializer_list<double> &x,
        const std::initializer_list<double> &y,
        const Argument &argument = ""
    ){
        plot(
            std::vector<double>(x),
            std::vector<double>(y),
            argument
        );
    }
private:
    enum class CurrentPlotType{None, Plot1D, PlotSurface, Contourf};
 
    CurrentPlotType currentPlotType;
 
    enum class PlotMethod3D{PlotSurface, Contourf};
 
    PlotMethod3D plotMethod3D;
 
    PlotParameters plotParameters;
 
    PlotSurfaceParameters plotSurfaceParameters;
 
    ContourfParameters contourfParameters;
 
    std::vector<std::pair<unsigned int, std::vector<double>>> axes;
 
    unsigned int numLines;
 
    unsigned int numContours;
 
    void plot1D(
        const std::vector<double> &y,
        const Argument &argument = ""
    );
 
    void plot1D(
        const std::vector<double> &x,
        const std::vector<double> &y,
        const Argument &argument = ""
    );
 
    void plot2D(
        const std::vector<std::vector<double>> &z,
        const Argument &argument = ""
    );
 
    void plot2D(
        const std::vector<std::vector<double>> &x,
        const std::vector<std::vector<double>> &y,
        const std::vector<std::vector<double>> &z,
        const Argument &argument = ""
    );
 
    AnnotatedArray<double, double> convertAxes(
        const AnnotatedArray<double, Subindex> &annotatedArray,
        const std::initializer_list<
            std::pair<unsigned int, std::pair<double, double>>
        > &axisReplacement = {}
    );
 
    Array<double> getNonDefaultAxis(
        const Array<double> &axis,
        unsigned int axisID
    ) const;
 
    AnnotatedArray<double, Subindex> convertSpinMatrixToDouble(
        const AnnotatedArray<SpinMatrix, Subindex> &annotatedArray,
        const Vector3d &direction
    ) const;
 
    std::string colorToHex(const Array<double> &color) const;
 
    std::string doubleToHex(double value) const;
};
 
inline Plotter::Plotter(){
    currentPlotType = CurrentPlotType::None;
    plotMethod3D = PlotMethod3D::Contourf;
    numLines = 0;
    numContours = 8;
    clear();
}
 
inline void Plotter::setBoundsX(
    double minX,
    double maxX
){
    TBTKAssert(
        minX < maxX,
        "Plotter::setBoundsX()",
        "minX has to be smaller than maxX",
        ""
    );
    plotParameters.setBoundsX(minX, maxX);
    contourfParameters.setBoundsX(minX, maxX);
    plotSurfaceParameters.setBoundsX(minX, maxX);
}
 
inline void Plotter::setBoundsY(
    double minY,
    double maxY
){
    TBTKAssert(
        minY < maxY,
        "Plotter::setBoundsY()",
        "minY has to be smaller than maxY",
        ""
    );
    plotParameters.setBoundsY(minY, maxY);
    contourfParameters.setBoundsY(minY, maxY);
    plotSurfaceParameters.setBoundsY(minY, maxY);
}
 
inline void Plotter::setBounds(
    double minX,
    double maxX,
    double minY,
    double maxY
){
    setBoundsX(minX, maxX);
    setBoundsY(minY, maxY);
}
 
/*inline void Plotter::setAutoScaleX(bool autoScaleX){
    this->autoScaleX = autoScaleX;
}
 
inline void Plotter::setAutoScaleY(bool autoScaleY){
    this->autoScaleY = autoScaleY;
}
 
inline void Plotter::setAutoScale(bool autoScale){
    setAutoScaleX(autoScale);
    setAutoScaleY(autoScale);
}*/
 
inline void Plotter::setAxes(
    const std::vector<
        std::pair<unsigned int, std::vector<double>>
    > &axes
){
    this->axes = axes;
}
 
inline void Plotter::setTitle(const std::string &title, bool overwrite){
    plotParameters.setTitle(title, overwrite);
    plotSurfaceParameters.setTitle(title, overwrite);
    contourfParameters.setTitle(title, overwrite);
    matplotlibcpp::title(title);
}
 
inline void Plotter::setLabelX(const std::string &labelX, bool overwrite){
    plotParameters.setLabelX(labelX, overwrite);
    plotSurfaceParameters.setLabelX(labelX, overwrite);
    contourfParameters.setLabelX(labelX, overwrite);
    matplotlibcpp::xlabel(labelX);
}
 
inline void Plotter::setLabelY(const std::string &labelY, bool overwrite){
    plotParameters.setLabelY(labelY, overwrite);
    plotSurfaceParameters.setLabelY(labelY, overwrite);
    contourfParameters.setLabelY(labelY, overwrite);
    matplotlibcpp::ylabel(labelY);
}
 
inline void Plotter::setLabelZ(const std::string &labelZ, bool overwrite){
    plotSurfaceParameters.setLabelZ(labelZ, overwrite);
}
 
inline void Plotter::setPlotMethod3D(const std::string &plotMethod3D){
    if(plotMethod3D.compare("plot_surface") == 0){
        this->plotMethod3D = PlotMethod3D::PlotSurface;
    }
    else if(plotMethod3D.compare("contourf") == 0){
        this->plotMethod3D = PlotMethod3D::Contourf;
    }
    else{
        TBTKExit(
            "Plotter::setPlotMethod3D()",
            "Unknown plot method.",
            "Must be 'plot_surface' or 'contourf'."
        );
    }
}
 
inline void Plotter::setRotation(int elevation, int azimuthal, bool overwrite){
    plotSurfaceParameters.setRotation(elevation, azimuthal, overwrite);
    switch(currentPlotType){
    case CurrentPlotType::PlotSurface:
        plotSurfaceParameters.flush();
        break;
    default:
        break;
    }
}
 
inline void Plotter::setNumContours(unsigned int numContours){
    this->numContours = numContours;
}
 
/*inline void Plotter::setHold(bool hold){
    this->hold = hold;
}*/
 
inline void Plotter::clear(){
    plotParameters.clear();
    plotSurfaceParameters.clear();
    contourfParameters.clear();
    axes.clear();
    numLines = 0;
    numContours = 8;
    matplotlibcpp::clf();
}
 
inline void Plotter::show() const{
    matplotlibcpp::show();
}
 
inline void Plotter::save(const std::string &filename) const{
    matplotlibcpp::save(filename);
}
 
};  //End namespace MatPlotLib
};  //End namespace Visualization
};  //End namespace TBTK
 
#endif