NSE_MGLevel.h

// =======================================================================
// @(#)NSE_MGLevel.h        1.10 07/03/00
//
// Class:       TNSE_MGLevel
// Purpose:     abstract super class for a Stokes/Navier-Stokes system
//
// Author:      Volker John 25.07.2000
//
// History:     25.07.2000 start of implementation
//
// =======================================================================

#ifndef __NSE_MGLEVEL__
#define __NSE_MGLEVEL__

#include <Matrix.h>
#ifdef __2D__
   #include <SquareMatrix2D.h>
#endif  
#ifdef __3D__
   #include <SquareMatrix3D.h>
#endif  

class TNSE_MGLevel
{
  protected:
    int Level;

    int Type;

#ifdef __2D__

    TFESpace2D *USpace;

    TFESpace2D *PSpace;
#endif  

#ifdef __3D__

    TFESpace3D *USpace;

    TFESpace3D *PSpace;
#endif  

    int N_Dirichlet;

    int N_Active;

    int HangingNodeBound;

    int N_DOF;

    int N_UDOF;

    int N_PDOF;

    int VelocitySpace;

    int PressureSpace;

    double *Rhs1;

    double *Rhs2;

#ifdef __3D__

    double *Rhs3;
#endif  

    double *RhsP;

    double *U1;

    double *U2;

#ifdef __3D__

    double *U3;
#endif  

    double *P;

    int N_Aux;

    double **Aux;

    double *Additional;

    double alpha;

    double beta;

    TCollection *VankaColl;

    int *downwind;

    int *velo_velo_local_coupling;

    int *gradient_local_coupling;

    int *divergence_local_coupling;

  public:
    TNSE_MGLevel(int level, double *f1, double *u1,
                 int n_aux, double *al, int VelocitySpace, 
                 int PressureSpace,
                 TCollection *coll);

    ~TNSE_MGLevel();

    double *GetAuxVector(int i);

#ifdef __2D__

    void GetSolution(double* &u1, double* &u2, double* &p)
      { u1 = U1; u2 = U2; p = P; }

    void GetRhs(double* &f1, double* &f2, double* &f3)
    { f1 = Rhs1; f2 = Rhs2; f3 = RhsP;}
#endif  
#ifdef __3D__

    void GetSolution(double* &u1, double* &u2, double* &u3, double* &p)
      { u1 = U1; u2 = U2; u3 = U3; p = P; }

    void GetRhs(double* &f1, double* &f2, double* &f3, double* &f4)
    { f1 = Rhs1; f2 = Rhs2; f3 = Rhs3; f4 = RhsP;}
#endif  

    void GetSolutionVector(double* &u1)
      { u1 = U1;}

    void GetRhsVector(double* &f1)
    { f1 = Rhs1;}

    double **GetAuxVectors()
    { return Aux; }

    int GetN_UDOF()
    { return N_UDOF; }

    int GetN_PDOF()
    { return N_PDOF; }

    int GetVelocitySpace()
    { return VelocitySpace; }

    int GetPressureSpace()
    { return PressureSpace; }

    int GetHangingNodeBound()
    { return HangingNodeBound; }

    int GetN_Dirichlet()
    { return N_Dirichlet; }

    virtual void Defect(double *u1, double *f1, double *d1, double &res);

    void Update(double *u1, double *v1);

    virtual void CorrectNodes(double *u1);

    void SetHangingNodes(double *u1);

    void CorrectDefect(double *v1);

    void Reset(double *v1);

#ifdef __2D__

    TFESpace2D *GetUSpace()
    { return USpace; }

    TFESpace2D *GetPSpace()
    { return PSpace; }
#endif  

#ifdef __3D__

    TFESpace3D *GetUSpace()
    { return USpace; }

    TFESpace3D *GetPSpace()
    { return PSpace; }
#endif  

    TCollection *GetCollection()
    { return VankaColl; }

    void SetCollection(TCollection *coll)
    { VankaColl = coll; }

    virtual void CellVanka(double *u1, double *rhs1, double *aux, 
        int N_Parameters, double *Parameters, int smoother, int N_Levels);

    virtual void NodalVanka(double *u1, double *rhs1, double *aux, 
        int N_Parameters, double *Parameters, int smoother, int N_Levels);

    virtual void SolveExact(double *u1, double *rhs1);

    virtual void SolveExactUMFPACK(double *u1, double *rhs1, int &umfpack_flag);

    virtual void BraessSarazin(double *u1, double *rhs1, double *aux,
        int N_Parameters, double *Parameters,int N_Levels);

    virtual double StepLengthControl(double *u1, double *u1old, double *def1,
                     int N_Parameters, double *Parameter);

    virtual void PrintAll();

    int GetType()
    { return Type; }

};

#endif