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

#ifndef QCBEC_H
#define QCBEC_H

#include "qcquantumsystem.h"
#include "qccomplexfield.h"
#include "qcphase.h"

template <int rank>
class QCBEC : public QCQuantumSystem<complexType,rank>
{
public:
    // -------------------------------------------------------
    QCBEC(void);
    ~QCBEC(void);

    // -------------------------------------------------------
    void setTrapFrequency(parameterType omegaValue)
    {   this->SystemParameters.setParameter(0,omegaValue);        }
    void setChemicalPotential(parameterType chemValue)
    {   this->SystemParameters.setParameter(1,chemValue);        }
    void setSelfInteraction(parameterType gValue)
    {   this->SystemParameters.setParameter(2,gValue);            }
    void setHBar(parameterType hbarValue)
    {   this->SystemParameters.setParameter(3,hbarValue);         }
    void setMass(parameterType massValue)
    {   this->SystemParameters.setParameter(4,massValue);         }
    void setAngularFrequency(parameterType bigOmegaValue)
    {   this->SystemParameters.setParameter(5,bigOmegaValue);     }
    void setWindingNumber(parameterType nValue)
    {   this->SystemParameters.setParameter(6,nValue);            }
        void setDisturbance(parameterType height, int position, int width);

    // -------------------------------------------------------
        parameterType getTrapFrequency()
        {   return this->SystemParameters.getParameter(0);            }
        parameterType getChemicalPotential()
        {   return this->SystemParameters.getParameter(1);            }
        parameterType getSelfInteraction()
        {   return this->SystemParameters.getParameter(2);            }
        parameterType getHBar()
        {   return this->SystemParameters.getParameter(3);            }
        parameterType getMass()
        {   return this->SystemParameters.getParameter(4);            }
        parameterType getAngularFrequency()
        {   return this->SystemParameters.getParameter(5);            }
        parameterType getWindingNumber()
        {   return this->SystemParameters.getParameter(5);            }
        void getDisturbance(parameterType &height, int &position, int &width);

        // -------------------------------------------------------
    virtual void windPhase()
    {   Phase.applyVortex(OrderParameter,this->deltaX,this->deltaY,this->xOffset,this->yOffset);    }
    virtual void constantPhase()
    {   Phase.applyUniform(OrderParameter,this->deltaX,this->deltaY,this->xOffset,this->yOffset);   }
    virtual void randomPhase()
    {   Phase.applyRandom(OrderParameter,this->deltaX,this->deltaY,this->xOffset,this->yOffset);    }
    virtual void applyPhaseDisturbance()
    {   Phase.applyDisturbanceTypeII(OrderParameter,this->deltaX,this->deltaY,this->xOffset,this->yOffset); }
    virtual void evolve(bool forwards);
    virtual void setupConstant();
    virtual void setupSteadyState();
    virtual void setupVortexSteadyState();
    virtual void setupSteadyStateGS();
    virtual void setupSteadyStateFSI();
    virtual void writeResults();

protected:
    QCPhase Phase; 
    QCComplexField<rank> OrderParameter; 
};

#endif // QCBEC_H

template <int rank>
QCBEC<rank>::QCBEC()
{
    this->ptrField = &OrderParameter;
    this->SystemParameters.setNoOfParameters(7);
}

template <int rank>
QCBEC<rank>::~QCBEC()
{
    //dtor
}

template <int rank>
void QCBEC<rank>::setDisturbance(parameterType height, int position, int width)
{
        Phase.setDisturbHeight(height);
        Phase.setDisturbPosition(position);
        Phase.setDisturbWidth(width);
}

template <int rank>
void QCBEC<rank>::getDisturbance(parameterType &height, int &position, int &width)
{
        height = Phase.getDisturbHeight();
        position = Phase.getDisturbPosition();
        width = Phase.getDisturbWidth();
}

template <int rank>
void QCBEC<rank>::evolve(bool forwards)
{
    this->Evolve.evolveForwards(forwards);
    this->Evolve.usingTDGP(OrderParameter,this->xOffset,this->yOffset,this->deltaX,this->deltaY,this->SystemParameters);
}

template <int rank>
void QCBEC<rank>::setupConstant()
{
    this->SteadyState.setConstant(OrderParameter);
}

template <int rank>
void QCBEC<rank>::setupSteadyState()
{
    this->SteadyState.usingTDGPFixedPoint(OrderParameter,this->deltaR,this->SystemParameters);
        this->SteadyState.transferSolutionTo(OrderParameter,this->xOffset,this->yOffset,this->deltaX,this->deltaY,this->deltaR);
        this->SteadyState.output1DSolution("Radial.csv",this->deltaR);
}

template <int rank>
void QCBEC<rank>::setupVortexSteadyState()
{
    this->SteadyState.usingTDGPVortexFixedPoint(OrderParameter,this->deltaR,this->SystemParameters);
        this->SteadyState.transferSolutionTo(OrderParameter,this->xOffset,this->yOffset,this->deltaX,this->deltaY,this->deltaR);
        this->SteadyState.output1DSolution("Radial.csv",this->deltaR);
}

template <int rank>
void QCBEC<rank>::setupSteadyStateFSI()
{
    /*this->SteadyState.usingTDGPFastSI(OrderParameter,this->deltaR,this->SystemParameters);
    this->SteadyState.transferSolutionTo(OrderParameter,this->xOffset,this->yOffset,this->deltaX,this->deltaY,this->deltaR);
    this->SteadyState.output1DSolution("FSITest.csv",this->deltaR);*/
}

template <int rank>
void QCBEC<rank>::setupSteadyStateGS()
{
    //this->SteadyState.usingTDGPGaussSeidel(OrderParameter,this->xOffset,this->yOffset,this->deltaX,this->deltaY,this->SystemParameters);
}

template <int rank>
void QCBEC<rank>::writeResults()
{
    OrderParameter.writeNormToFile("FinalNorm.csv");
        Phase.outputPhaseFunction(OrderParameter,"FinalPhase.csv");
}

---