include/qcfield.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 - QCField.h
        1.0.0 - Original Implementation
*/

#ifndef QCFIELD_H
#define QCFIELD_H

#include <fstream>
#include <blitz/array.h>

using namespace blitz;

typedef double fieldType;

static int filePrecision = 12;

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

        // -------------------------------------------------------
        void setSize(int noOfRows, int noOfCols)
        {       Field.resize(noOfRows,noOfCols);        }
        void resize(int noOfRows, int noOfCols)
        {       Field.resizeAndPreserve(noOfRows,noOfCols);     }
        Array<T,rank>* accessArray()
        {       return &Field;  }
        Array<T,rank>& array()
        {       return Field;   }

        // -------------------------------------------------------
        int noOfRows()
        {       return Field.rows();    }
        int noOfColumns()
        {       return Field.cols();    }
        int height()
        {       return Field.extent(thirdDim);  }

        // -------------------------------------------------------
        void assignElement(int atRow, int atCol, T value)
        {       Field(atRow,atCol) = value;     }
        void assignElement(int atRow, int atCol, int atHeight, T value)
        {       Field(atRow,atCol,atHeight) = value;    }
        T retrieveElement(int atRow, int atCol)
        {       return Field(atRow,atCol);      }
        T retrieveElement(int atRow, int atCol, int atHeight)
        {       return Field(atRow,atCol,atHeight);     }

        // -------------------------------------------------------
        void dumpToStdErr()
        {       cerr << Field;  }
        bool readFromFile(const char* fileName);
        bool writeToFile(const char* fileName);

protected:
        Array<T,rank> Field; 
};
#endif

template <typename T, int rank>
QCField<T,rank>::QCField(void)
{
}

template <typename T, int rank>
QCField<T,rank>::QCField(int noOfRows, int noOfCols)
{
        setSize(noOfRows,noOfCols);
}

template <typename T, int rank>
QCField<T,rank>::~QCField(void)
{
        Field.free();
}

template <typename T, int rank>
bool QCField<T,rank>::readFromFile(const char* fileName)
{
        ifstream inFile(fileName,ios::in);
        inFile.precision(filePrecision);

        if(inFile.fail())
        {
                cerr << "File Error: " << fileName << endl;
                return false;
        }
        else
        {
                inFile >> Field;
                inFile.close();
                return true;
        }
}

template <typename T, int rank>
bool QCField<T,rank>::writeToFile(const char* fileName)
{
        ofstream outFile(fileName,ios::out);
        outFile.precision(filePrecision);

        if(outFile.fail())
        {
                cerr << "File Error: " << fileName << endl;
                return false;
        }
        else
        {
                outFile << Field;
                outFile.close();
                return true;
        }
}

---