src/qcplot.cpp

/***************************************************************************
 *   Quantum Construct (qC++)                                              *
 *   The Quantum Physics Computational Library                             *
 *   Copyright (C) 2005 by Shekhar S. Chandra                              *
 *   Shekhar.Chandra@sci.monash,edu.au                                     *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
/*
        Ver Info - QCPlot.cpp
        1.0.0 - Original Implementation
*/

#include "qcplot.h"
#include <QFile>
#include <QTextStream>

QCPlot::QCPlot()
{
        setTitle("Simulation Plot");
        setScale(1,1,10);
        setShift(0.15,0,0);
        setZoom(1.0);
        for (unsigned i=0; i!=coordinates()->axes.size(); ++i)
        {
                coordinates()->axes[i].setMajors(7);
                coordinates()->axes[i].setMinors(4);
        }
        coordinates()->axes[X1].setLabelString("x-axis");
        coordinates()->axes[Y1].setLabelString("y-axis");
        coordinates()->axes[Z1].setLabelString("z-axis");
        setCoordinateStyle(FRAME);
        setPlotStyle(FILLED);
        showColorLegend(true);
        updateData();
        updateGL();
}

QCPlot::~QCPlot()
{
        free(ptrField);
}

void QCPlot::realPartOf(QCComplexField<2> field, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        free(ptrField);
        ptrField = (double **)malloc(field.noOfRows() * sizeof(double *));
        for(int j = 0; j < field.noOfRows(); j++)
                ptrField[j] = (double *)malloc(field.noOfColumns() * sizeof(double));

        for(int k = 0; k < field.noOfColumns(); k ++)
                for(int j = 0; j < field.noOfRows(); j ++)
                        ptrField[j][k] = (double)field.array()(j,k).real();

        loadFromData(ptrField, field.noOfColumns(), field.noOfRows(), minXRange, maxXRange, minYRange, maxYRange);
        resize(800,600);
}

void QCPlot::imagPartOf(QCComplexField<2> field, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        free(ptrField);
        ptrField = (double **)malloc(field.noOfRows() * sizeof(double *));
        for(int j = 0; j < field.noOfRows(); j++)
                ptrField[j] = (double *)malloc(field.noOfColumns() * sizeof(double));

        for(int k = 0; k < field.noOfColumns(); k ++)
                for(int j = 0; j < field.noOfRows(); j ++)
                        ptrField[j][k] = (double)field.array()(j,k).imag();

        loadFromData(ptrField, field.noOfColumns(), field.noOfRows(), minXRange, maxXRange, minYRange, maxYRange);
        resize(800,600);
}

void QCPlot::normOf(QCComplexField<2> field, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        free(ptrField);
        ptrField = (double **)malloc(field.noOfRows() * sizeof(double *));
        for(int j = 0; j < field.noOfRows(); j++)
                ptrField[j] = (double *)malloc(field.noOfColumns() * sizeof(double));

        for(int k = 0; k < field.noOfColumns(); k ++)
                for(int j = 0; j < field.noOfRows(); j ++)
                        ptrField[j][k] = (double)norm(field.array()(j,k));

        loadFromData(ptrField, field.noOfColumns(), field.noOfRows(), minXRange, maxXRange, minYRange, maxYRange);
        resize(800,600);
}

void QCPlot::normOf(QCComplexField<3> field, int slice, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        free(ptrField);
        ptrField = (double **)malloc(field.noOfRows() * sizeof(double *));
        for(int j = 0; j < field.noOfRows(); j++)
                ptrField[j] = (double *)malloc(field.noOfColumns() * sizeof(double));

        for(int k = 0; k < field.noOfColumns(); k ++)
                for(int j = 0; j < field.noOfRows(); j ++)
                        ptrField[j][k] = (double)norm(field.array()(j,k,slice));

        loadFromData(ptrField, field.noOfColumns(), field.noOfRows(), minXRange, maxXRange, minYRange, maxYRange);
        resize(800,600);
}

void QCPlot::phaseOf(QCComplexField<2> field, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        free(ptrField);
        ptrField = (double **)malloc(field.noOfRows() * sizeof(double *));
        for(int j = 0; j < field.noOfRows(); j++)
                ptrField[j] = (double *)malloc(field.noOfColumns() * sizeof(double));

        for(int k = 0; k < field.noOfColumns(); k ++)
                for(int j = 0; j < field.noOfRows(); j ++)
                        ptrField[j][k] = atan2(field.array()(j,k).imag(),field.array()(j,k).real());

        loadFromData(ptrField, field.noOfColumns(), field.noOfRows(), minXRange, maxXRange, minYRange, maxYRange);
        resize(800,600);
}

void QCPlot::phaseOf(QCComplexField<3> field, int slice, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        free(ptrField);
        ptrField = (double **)malloc(field.noOfRows() * sizeof(double *));
        for(int j = 0; j < field.noOfRows(); j++)
                ptrField[j] = (double *)malloc(field.noOfColumns() * sizeof(double));

        for(int k = 0; k < field.noOfColumns(); k ++)
                for(int j = 0; j < field.noOfRows(); j ++)
                        ptrField[j][k] = atan2(field.array()(j,k,slice).imag(),field.array()(j,k,slice).real());

        loadFromData(ptrField, field.noOfColumns(), field.noOfRows(), minXRange, maxXRange, minYRange, maxYRange);
        resize(800,600);
}

void QCPlot::loadFile(QString filename, int rows, int columns, double minXRange, double maxXRange, double minYRange, double maxYRange)
{
        /*QFile file(filename);
        QFile file2("test.csv");*/
        ofstream out("test.csv",ios::out);
        ifstream in(filename.toStdString().c_str(),ios::in);
        int j = 0, k = 0;
        char comma;

        free(ptrField);
        ptrField = (double **)malloc(rows * sizeof(double *));
        for(int l = 0; l < rows; l++)
                ptrField[l] = (double *)malloc(columns * sizeof(double));

    /*if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
        exit(0);
    if (!file2.open(QIODevice::WriteOnly | QIODevice::Text))
        exit(0);*/

        /*QTextStream in(&file);
        QTextStream out(stderr);
        in.setRealNumberNotation(QTextStream::ScientificNotation);
        out.setRealNumberNotation(QTextStream::ScientificNotation);*/
    while (!in.eof() && k < columns)
        {
                in >> ptrField[j][k];
                in >> comma;
                out << ptrField[j][k];
                out << comma;
                j ++;
                if (j == rows)
                {
                        k ++;
                        j = 0;
                }
    }

        loadFromData(ptrField, columns, rows, minXRange, maxXRange, minYRange, maxYRange);
}

void QCPlot::outputPDF(QString filename)
{
        save(filename,"PDF");
}

void QCPlot::outputPS(QString filename)
{
        save(filename,"PS");
}

void QCPlot::outputEPS(QString filename)
{
        save(filename,"EPS");
}

---