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

#ifndef QCQUANTUMSYSTEM_H
#define QCQUANTUMSYSTEM_H

#include <string>

#include "qcevolve.h"
#include "qcsteadystate.h"
#include "qcparameter.h"

template <typename T, int rank>
class QCQuantumSystem
{
public:
        // -------------------------------------------------------
        QCQuantumSystem(void);
        virtual ~QCQuantumSystem(void);

        // -------------------------------------------------------
        virtual void setSize(int noOfRows, int noOfCols)
        {       if(ptrField != NULL) ptrField->setSize(noOfRows,noOfCols);      }
        void resize(int &noOfRows, int &noOfCols)
        {       if(ptrField != NULL) ptrField->resize(noOfRows,noOfCols);       }
        void setDeltaT(parameterType value)
        {       Evolve.setTimeStep(value);              }
        void setDeltaX(parameterType value)
        {       deltaX = value;                     }
        void setDeltaY(parameterType value)
        {       deltaY = value;                     }
        void setDeltaR(parameterType value)
        {       deltaR = value;                     }
        void setXOffset(int value)
        {       xOffset = value;                        }
        void setYOffset(int value)
        {       yOffset = value;                        }
        void setTolerance(parameterType value)
        {       SteadyState.setTolerance(value);        }
        void setFileName(string name)
        {       outFileName = name;                     }

        int getNoOfRows();
        int getNoOfColumns();
        parameterType getDeltaT()
        {       return Evolve.getTimeStep();        }
        parameterType getDeltaX()
        {       return deltaX;                      }
        parameterType getDeltaY()
        {       return deltaY;                      }
        parameterType getDeltaR()
        {       return deltaR;                      }
        parameterType getXOffset()
        {       return xOffset;                     }
        parameterType getYOffset()
        {       return yOffset;                     }
        parameterType getTolerance()
        {       return SteadyState.getTolerance();      }
        string getFileName()
        {       return outFileName;     }
        const char* getFileNameCSTR()
        {       return outFileName.c_str();             }
        virtual void writeImage(int shot, string filePrefix, string extension);
        Array<T,rank>* accessData()
        {   return ptrField->accessArray();     }

protected:
        QCEvolve Evolve; 
        QCSteadyState SteadyState; 
        QCField<T,rank> *ptrField; 
        QCParameter SystemParameters; 
        parameterType deltaX; 
        parameterType deltaY; 
        parameterType deltaR; 
        int xOffset; 
        int yOffset; 
        string outFileName; 
};
#endif

template <typename T, int rank>
QCQuantumSystem<T,rank>::QCQuantumSystem(void)
{
        ptrField = NULL;
}

template <typename T, int rank>
QCQuantumSystem<T,rank>::~QCQuantumSystem(void)
{
        delete ptrField;
}

template <typename T, int rank>
int QCQuantumSystem<T,rank>::getNoOfRows()
{
        if(ptrField != NULL)
                return ptrField->noOfRows();
        else
                return 0;
}

template <typename T, int rank>
int QCQuantumSystem<T,rank>::getNoOfColumns()
{
        if(ptrField != NULL)
                return ptrField->noOfColumns();
        else
                return 0;
}

template <typename T, int rank>
void QCQuantumSystem<T,rank>::writeImage(int shot, string filePrefix, string extension)
{
    char digit = static_cast<char> (shot + 48);
    string filename = filePrefix + digit + extension;

    ptrField->writeToFile(filename.c_str());
}

---