---

multigrid.h

Go to the documentation of this file.

/*
 * Copyright (c) 2001 The AUTHORS 
 *   Romeu Andre' Pieritz, Ph.D.        - romeu_pieritz@hotmail.com
 *   Rafael Mendes, Eng.                – mendes_rafael@yahoo.com
 *   Rodrigo Ferraz de Andrade, Eng.    – rferraz@iname.com 
 * All rights reserved.
 *
 * Permission to use, copy and distribute this software and its
 * documentation for educational and personal use, without fee is hereby granted, 
 * provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS
 * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HERE UNDER IS
 * ON AN "AS IS" BASIS, AND THE AUTHORS HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * SINMEC Lab. - CFD Sinflow Project - http://www.sinmec.ufsc.br/cfd
 */


// File Define
#ifndef __CSFL_MATH_SOLVER_MULTIGRID_H__
#define __CSFL_MATH_SOLVER_MULTIGRID_H__


// Include
#include <csfl/math/solver/itsolver.h>
#include <csfl/sys/math/linearsys9d.h>
#include <csfl/math/solver/tdma.h>
#include <csfl/math/solver/lu.h>



// Namespace
namespace csfl { 

typedef
        enum _TMGSequence {
                mgsV,
                mgsW,
                mgsF            
        }
        TMGSequence;


// Predefinition required
class ISolverIterMultiGrid;

//==============================================================================
//              Class IMultiGridLevel
//              Description: retains all the information about a Multi-Grid Level,
//                                       including its Lynear System
//==============================================================================

class IMultiGridLevel
{
public:
        IMultiGridLevel();
        IMultiGridLevel( IMultiGridLevel *_mgl);
        IMultiGridLevel(int _ni,
                        int _nj);
        ~IMultiGridLevel();


        IPoint CoordIni( const int & i, const int & j ) 
                { return ( Cini )? Cini->Value( i, j ) : IPoint::zero; }


        IPoint CoordEnd( const int & i, const int & j ) 
                { return ( Cend )? Cend->Value( i, j ) : IPoint::zero; }



        int NI() { return ni; }

        
        int NJ() { return nj; }

        
        IMultiGridLevel & operator =( const IMultiGridLevel & );

        

protected:
        
        ILinearSystem * LinearSystem() { return lsys; }
        
        void SetSize( const ISize & _size );

        void SetCini( const int & i, const int & j, const IPoint & value ) 
                { if( Cini ) Cini->SetValue( i, j, value ); }
        

        void SetCend( const int & i, const int & j, const IPoint & value ) 
                { if( Cend ) Cend->SetValue( i, j, value ); }

protected:
        
        ILinearSystem9D *lsys;
        
        int ni, nj; //Level Size

        MatrixPoint *Cini, *Cend; //Coordinates in the subsequent refined mesh

        friend class ISolverIterMultiGrid;
};




//==============================================================================
//              Class ISolverIterMultiGrid
//              Description: Coordinates the Multi-Grid Solver
//==============================================================================

class ISolverIterMultiGrid : 
        public ISolverIteract 

{

public:
        ISolverIterMultiGrid( ISize _agglomerator,
                ILinearSystem *_lsys = NULL, 
                double _tol = 0.001, 
                int _iterMax = 100,
                TMGSequence _MGsequence = mgsV,
                IContainerParameter *_cont = NULL );

        ISolverIterMultiGrid( ILinearSystem *_lsys = NULL, 
                double _tol = 0.001, 
                int _itermax = 100,
                TMGSequence _MGsequence = mgsV,
                IContainerParameter * = NULL );

        ISolverIterMultiGrid( ISolverIterMultiGrid * );

        ~ISolverIterMultiGrid();
        
        void Solve();
                
        void Solve( ILinearSystem *_lsys );
                
        IMultiGridLevel * MultiGridLevels() { return MGL; }
        
        ISize Agglomerator() { return agglomerator; }

                
        void SetAgglomerator( const ISize & _agglomerator );
        
        int Levels() { return levels; }
        
        void SetMaximumNumberOfLevels( const int & _maxLevels ) { maxLevels = _maxLevels; }
                
        int LevelMaximumIteration() { return MGiterMax; }
        
        void SetLevelMaximumIteration( const int & _maxiter ) { MGiterMax = _maxiter; } 
        
        int LevelIteration() { return MGiter; }
                
        int CoarsenSize() { return coarsensize; }
                
        void SetCoarsenSize( int _size ){ coarsensize = _size; }
                
        double LevelResidualReduction() { return MGreduction; }
                        
        void SetLevelResidualReduction( const double & _red ) { MGreduction = _red; }

        double LevelError() { return MGerror; }

        
        TMGSequence MultiGridSequence() { return MGsequence; }

        void SetFicticiousVolumes( const bool & _FictVol ) { FictVolumes = _FictVol; }

    void SetIterToEvaluateError( int _v );

    void SolveWhenCoarsening( bool _swcoarsening ) { swcoarsening = _swcoarsening; }
 
        IAction ActionSolveLevel;
         
        IAction ActionLevelConverged;
        
    void Write( ofstream &_os );

protected:
        void SolveCoarsening();
        void SolveRefining();
        void CreateLevels();
        void SetCoefficients();
        void SetResiduals( int _level );
        void MakeCorrection ( int _level );
        void CheckMagnitudeReduction( ISFLObject * = NULL );
        void SolveCall( ISFLObject * = NULL );
        void ComputeAgglomerator();

        int levels;
        IMultiGridLevel * MGL;
        int ni, nj;
        ISize agglomerator;
        bool swcoarsening;
        
        int             MGiterMax, MGiter;
        int coarsensize;
        double  MGreduction, MGinitialError, MGerror;
        TMGSequence MGsequence;

        ISolverIterTdma * RefinedSolver;
        ISolverLU * CoarsenSolver;
        bool FictVolumes;

};


} // csfl namespace

#endif // __CSFL_MATH_SOLVER_MULTIGRID__

 

CFD Project | Documents | Downloads | Contact us | Use Terms
© SINMEC/EMC/UFSC, 2001.	All rights reserved.	Last Update: Jan. 18, 2002	Webmaster