include/qccomplexfield.h

/***************************************************************************
 *   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 - QCComplexField.h
        1.0.0 - Original Implementation
*/

#ifndef QCCOMPLEXFIELD_H
#define QCCOMPLEXFIELD_H

#include <complex>

#include "qcfield.h"

using namespace std;

typedef complex<fieldType> complexType;

static complexType i(0,1);
static complexType complexZero(0,0);

enum formatType{CSV = 0, GNU};

template <int rank>
class QCComplexField : public QCField<complexType,rank>
{
public:
        // -------------------------------------------------------
        QCComplexField(void);
        QCComplexField(int noOfRows, int noOfCols);
        ~QCComplexField(void);

        // -------------------------------------------------------
        void initializeToZero();
        void initializeToUnity(bool realPart, bool imagPart);

        // -------------------------------------------------------
        Array<fieldType,rank> realPart();
        Array<fieldType,rank> imaginaryPart();

        // -------------------------------------------------------
        bool writeRealToFile(const char* fileName);
        bool writeImagToFile(const char* fileName);
        bool writeNormToFile(const char* fileName);
        void setFormatCSV()
        {       outputFormat = CSV;     }
        void setFormatGNU()
        {       outputFormat = GNU;     }
private:
        formatType outputFormat; 
};

template <int rank>
QCComplexField<rank>::QCComplexField(void)
{
        setFormatCSV();
}

template <int rank>
QCComplexField<rank>::QCComplexField(int noOfRows, int noOfCols)
{
        this->setSize(noOfRows,noOfCols);
}

template <int rank>
QCComplexField<rank>::~QCComplexField(void)
{
}

template <int rank>
void QCComplexField<rank>::initializeToZero()
{
        complexType tmp(0.0,0.0);
        if(this->Field.rows() > 0 || this->Field.cols() > 0)
                this->Field = tmp;
}

template <int rank>
void QCComplexField<rank>::initializeToUnity(bool realPart, bool imagPart)
{
        complexType tmp(0.0,0.0);

        if(realPart)
                tmp = tmp + 1.0;
        if(imagPart)
                tmp = tmp + i;

        if(this->Field.rows() > 0 || this->Field.cols() > 0)
                this->Field = tmp;
}

template <int rank>
Array<fieldType,rank> QCComplexField<rank>::realPart()
{
        return real(this->Field);
}

template <int rank>
Array<fieldType,rank> QCComplexField<rank>::imaginaryPart()
{
        return imag(this->Field);
}

template <int rank>
bool QCComplexField<rank>::writeRealToFile(const char* fileName)
{
        ofstream outFile(fileName,ios::out);
        outFile.precision(filePrecision);

        if(outFile.fail())
        {
                cerr << "File Error: " << fileName << endl;
                return false;
        }
        else
        {
                if(outputFormat == CSV)
                {
                        for(int k = 0; k < this->Field.cols(); k ++)
                        {
                                for(int j = 0; j < this->Field.rows(); j ++)
                                        outFile << this->Field(j,k).real() << " , ";
                                outFile << endl;
                        }
                }
                else if (outputFormat == GNU)
                {
                        outFile << "#The following is the Real part of the Solution" << endl;
                        outFile << "#x values \t\t y values \t\t Magnitude" << endl;
                        for(int k = 0; k < this->Field.cols(); k ++)
                        {
                                for(int j = 0; j < this->Field.rows(); j ++)
                                {
                                        outFile << j << "\t\t" << k << "\t\t" << this->Field(j,k).real() << endl;
                                }
                        }
                }
                outFile.close();
                return true;
        }
}

template <int rank>
bool QCComplexField<rank>::writeImagToFile(const char* fileName)
{
        ofstream outFile(fileName,ios::out);
        outFile.precision(filePrecision);

        if(outFile.fail())
        {
                cerr << "File Error: " << fileName << endl;
                return false;
        }
        else
        {
                if (outputFormat == CSV)
                {
                        for(int k = 0; k < this->Field.cols(); k ++)
                        {
                                for(int j = 0; j < this->Field.rows(); j ++)
                                        outFile << this->Field(j,k).imag() << " , ";
                                outFile << endl;
                        }
                }
                else if (outputFormat == GNU)
                {
                        outFile << "#The following is the Imaginary part of the Solution" << endl;
                        outFile << "#x values \t\t y values \t\t Magnitude" << endl;
                        for(int k = 0; k < this->Field.cols(); k ++)
                        {
                                for(int j = 0; j < this->Field.rows(); j ++)
                                {
                                        outFile << j << "\t\t" << k << "\t\t" << this->Field(j,k).imag() << endl;
                                }
                        }
                }
                outFile.close();
                return true;
        }
}

template <int rank>
bool QCComplexField<rank>::writeNormToFile(const char* fileName)
{
        ofstream outFile(fileName,ios::out);
        outFile.precision(filePrecision);

        if(outFile.fail())
        {
                cerr << "File Error: " << fileName << endl;
                return false;
        }
        else
        {
                if (outputFormat == CSV)
                {
                        if(rank == 2)
                        {
                                for(int k = 0; k < this->Field.cols(); k ++)
                                {
                                        for(int j = 0; j < this->Field.rows(); j ++)
                                                outFile << norm(this->Field(j,k)) << " , ";
                                        outFile << endl;
                                }
                        }
                        else
                        {
                                int l = this->Field.cols()/2;
                                for(int k = 0; k < this->Field.cols(); k ++)
                                {
                                        for(int j = 0; j < this->Field.rows(); j ++)
                                                outFile << norm(this->Field(j,k,l)) << " , ";
                                        outFile << endl;
                                }
                        }
                }
                else if (outputFormat == GNU)
                {
                        outFile << "#The following is the Norm of the Solution" << endl;
                        outFile << "#x values \t\t y values \t\t Magnitude" << endl;
                        for(int k = 0; k < this->Field.cols(); k ++)
                        {
                                for(int j = 0; j < this->Field.rows(); j ++)
                                {
                                        outFile << j << "\t\t" << k << "\t\t" << norm(this->Field(j,k)) << endl;
                                }
                        }
                }
                outFile.close();
                return true;
        }
}
#endif

---