#include <multigrid_solver.h>

Inheritance diagram for MultiGridSolver< NDIM, T >:

Public Types
enum	Exit_Status { Exit_Status::SUCCESS, Exit_Status::FAILURE, Exit_Status::SLOW, Exit_Status::ITERATE, Exit_Status::MAX_STEPS }

Public Member Functions
	MultiGridSolver ()

	MultiGridSolver (size_t N)

	MultiGridSolver (size_t N, bool verbose)

	MultiGridSolver (size_t N, size_t Nmin, bool verbose)

size_t	get_istep () const

T *	get_y (size_t level=0)

T const *	get_y (size_t level=0) const

Grid< NDIM, T > &	get_grid (size_t level=0)

const Grid< NDIM, T > &	get_grid (size_t level=0) const

MultiGrid< NDIM, T > &	get_mlt_grid (size_t level=0)

const MultiGrid< NDIM, T > &	get_mlt_grid (size_t level=0) const

T *	get_external_field (size_t level, size_t field)

T const *	get_external_field (size_t level, size_t field) const

Grid< NDIM, T > &	get_external_grid (size_t level, size_t field)

const Grid< NDIM, T > &	get_external_grid (size_t level, size_t field) const

size_t	get_external_field_size () const

T	get_multigrid_source (size_t level, size_t i) const

void	set_epsilon (double eps_converge)

void	set_maxsteps (size_t maxsteps)

void	set_ngs_sweeps (size_t ngs_fine, size_t ngs_coarse)

void	set_convergence_criterion_residual (bool use_residual)

void	set_Nlevel (size_t N)

size_t	get_N (size_t level=0) const

size_t	get_Ntot (size_t level=0) const

size_t	get_Nlevel () const

void	add_external_grid (MultiGrid< NDIM, T > *field)

void	set_initial_guess (T guess)

void	set_initial_guess (T *guess)

void	set_initial_guess (Grid< NDIM, T > &guess)

Exit_Status	solve ()

void	clear ()

virtual T	upd_operator (const T f, const size_t level, const std::vector< size_t > &index_list, const T h) const

virtual T	l_operator (const size_t level, const std::vector< size_t > &index_list, bool addsource, const T h) const

virtual T	dl_operator (const size_t level, const std::vector< size_t > &index_list, const T h) const

virtual void	correct_sol (Grid< NDIM, T > &f, const Grid< NDIM, T > &corr, const size_t level)

virtual Exit_Status	check_convergence ()

virtual void	check_solution (size_t level, Grid< NDIM, T > &sol)

void	check_solution (size_t level)

Public Attributes
bool	_store_all_residual = false

std::vector< double >	_res_domain_array

Protected Member Functions
void	get_neighbor_gridindex (std::vector< size_t > &index_list, size_t i, size_t ngrid)

Protected Attributes
bool	_verbose

bool	_conv_criterion_residual = true

double	_eps_converge = 1e-5

size_t	_maxsteps = 1000

size_t	_istep_vcycle = 0

double	_rms_res

double	_rms_res_i

double	_rms_res_old

Private Member Functions
double	calculate_residual (size_t level, Grid< NDIM, T > &res)

void	prolonge_up_array (size_t to_level, Grid< NDIM, T > &BottomGrid, Grid< NDIM, T > &TopGrid)

void	make_prolongation_array (Grid< NDIM, T > &f, Grid< NDIM, T > &Rf, Grid< NDIM, T > &df)

void	GaussSeidelSweep (size_t level, size_t curcolor, T *f)

void	solve_current_level (size_t level)

void	recursive_go_up (size_t to_level)

void	recursive_go_down (size_t from_level)

void	make_new_source (size_t level)

Private Attributes
size_t	_N

size_t	_Ntot

size_t	_Nmin

size_t	_Nlevel

MultiGrid< NDIM, T >	_f

MultiGrid< NDIM, T >	_res

MultiGrid< NDIM, T >	_source

std::vector< MultiGrid< NDIM, T > * >	_ext_field

size_t	_ngs_coarse = 2

size_t	_ngs_fine = 2

size_t	_ngridcolours = 2

size_t	_tot_sweeps_domain_grid = 0

Detailed Description

template<size_t NDIM, typename T>
class MultiGridSolver< NDIM, T >

Definition at line 48 of file multigrid_solver.h.

Member Enumeration Documentation

template<size_t NDIM, typename T>

enum MultiGridSolver::Exit_Status

strong

Enumerator
SUCCESS
FAILURE
SLOW
ITERATE
MAX_STEPS

Definition at line 105 of file multigrid_solver.h.

105 {SUCCESS, FAILURE, SLOW, ITERATE, MAX_STEPS };

Constructor & Destructor Documentation

template<size_t NDIM, typename T>

MultiGridSolver< NDIM, T >::MultiGridSolver ( )

inline

Definition at line 111 of file multigrid_solver.h.

Referenced by MultiGridSolver< 3, T >::MultiGridSolver().

111 {}

template<size_t NDIM, typename T>

MultiGridSolver< NDIM, T >::MultiGridSolver ( size_t N )

inline

Definition at line 112 of file multigrid_solver.h.

112 : MultiGridSolver(N, true) {}

MultiGridSolver::MultiGridSolver

MultiGridSolver()

Definition: multigrid_solver.h:111

template<size_t NDIM, typename T>

MultiGridSolver< NDIM, T >::MultiGridSolver	(	size_t	N,
		bool	verbose
	)

inline

Definition at line 113 of file multigrid_solver.h.

113 : MultiGridSolver(N, 2, verbose) {}

MultiGridSolver::MultiGridSolver

MultiGridSolver()

Definition: multigrid_solver.h:111

template<size_t NDIM, typename T >

MultiGridSolver< NDIM, T >::MultiGridSolver	(	size_t	N,
		size_t	Nmin,
		bool	verbose
	)

Definition at line 209 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_N, MultiGridSolver< NDIM, T >::_Nlevel, MultiGridSolver< NDIM, T >::_res, MultiGridSolver< NDIM, T >::_source, and power().

                                                                             :
   _N(N), _Ntot(power(N, NDIM)), _Nmin(Nmin), _Nlevel(int(log2(N / _Nmin) + 1)), _verbose(verbose), 
   _rms_res(0.0), _rms_res_i(0.0), _rms_res_old(0.0) {
 
     // Check that N is divisible by 2^{Nlevel - 1} which is required for the restriction to make sense
     assert( ( _N / power(2, _Nlevel - 1) ) * power(2, _Nlevel - 1) == _N); 
 
     // We should have atleast 1 level
     assert(_Nlevel >= 1);                 
 
     // Allocate memory
     _f      = MultiGrid<NDIM,T>(_N, _Nlevel);
     _source = MultiGrid<NDIM,T>(_N, _Nlevel);
     _res    = MultiGrid<NDIM,T>(_N, _Nlevel);
   }

Member Function Documentation

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::add_external_grid ( MultiGrid< NDIM, T > * field )

Definition at line 160 of file multigrid_solver.cpp.

References MultiGrid< NDIM, T >::get_Nlevel().

Referenced by ContinuitySolver< NDIM, T >::ContinuitySolver(), MultiGridSolver< 3, T >::get_multigrid_source(), main(), and PoissonSolver< NDIM, T >::PoissonSolver().

                                                                        { 
   assert(field->get_Nlevel() >= _Nlevel);
   _ext_field.push_back(field); 
 }

template<size_t NDIM, typename T>

double MultiGridSolver< NDIM, T >::calculate_residual	(	size_t	level,
		Grid< NDIM, T > &	res
	)

private

Definition at line 282 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::get_N(), MultiGridSolver< NDIM, T >::get_neighbor_gridindex(), MultiGridSolver< NDIM, T >::get_Ntot(), ccl_test_distances::h, MultiGridSolver< NDIM, T >::l_operator(), Grid< NDIM, T >::rms_norm(), and growth_allz::T.

Referenced by MultiGridSolver< NDIM, T >::recursive_go_up(), and MultiGridSolver< NDIM, T >::solve_current_level().

                                                                                  {
   size_t N    = get_N(level);
   size_t Ntot = get_Ntot(level);
 
   // Gridspacing
   const T h = 1.0/T( get_N(level) );
 
   // Calculate and store (minus) the residual in each cell
 #ifdef OPENMP
 #pragma omp parallel for
 #endif
   for (size_t i = 0; i < Ntot; i++) {
     std::vector<size_t> index_list;
     get_neighbor_gridindex(index_list, i, N);
     res[i] = -l_operator(level, index_list, true, h);
   }
 
   // Calculate and return RMS residual
   return res.rms_norm();
 }

template<size_t NDIM, typename T >

MultiGridSolver< NDIM, T >::Exit_Status MultiGridSolver< NDIM, T >::check_convergence ( )

virtual

Reimplemented in anonymous_namespace{chameleon.cpp}::ChiSolver< T >.

Definition at line 311 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_conv_criterion_residual, MultiGridSolver< NDIM, T >::_eps_converge, MultiGridSolver< NDIM, T >::_istep_vcycle, MultiGridSolver< NDIM, T >::_maxsteps, MultiGridSolver< NDIM, T >::_rms_res, MultiGridSolver< NDIM, T >::_rms_res_i, MultiGridSolver< NDIM, T >::_rms_res_old, MultiGridSolver< NDIM, T >::_verbose, MultiGridSolver< NDIM, T >::ITERATE, MultiGridSolver< NDIM, T >::MAX_STEPS, and MultiGridSolver< NDIM, T >::SUCCESS.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source().

                                                                                       {
   // Compute ratio of residual to initial residual
   double err = _rms_res_i != 0.0 ? _rms_res/_rms_res_i : 1.0;
   Exit_Status converged = Exit_Status::ITERATE;
 
   // Print out some information
   if(_verbose){
     BOOST_LOG_TRIVIAL(debug) << "    Checking for convergence at step = " << _istep_vcycle << std::endl;
     BOOST_LOG_TRIVIAL(debug) << "        Residual = " << _rms_res << "  Residual_old = " <<  _rms_res_old << std::endl;
     BOOST_LOG_TRIVIAL(debug) << "        Residual_i = " << _rms_res_i << "  Err = " << err << std::endl;
   }
 
   // Convergence criterion
   if(_conv_criterion_residual) {
 
     // Convergence criterion based on the residual
     if(_rms_res < _eps_converge){
       if(_verbose || true){
         BOOST_LOG_TRIVIAL(debug) << std::endl;
         BOOST_LOG_TRIVIAL(debug) << "    The solution has converged res = " << _rms_res << " < " << _eps_converge << " istep = " << _istep_vcycle << "\n" << std::endl;
       }
       converged = Exit_Status::SUCCESS;
     } else {
       if(_verbose){
         BOOST_LOG_TRIVIAL(debug) << "    The solution has not yet converged res = " << _rms_res << " !< " << _eps_converge << std::endl; 
       }
     }
 
   } else {
 
     // Convergence criterion based on the ratio of the residual
     if(err < _eps_converge){
       if(_verbose || true){
         BOOST_LOG_TRIVIAL(debug) << std::endl;
         BOOST_LOG_TRIVIAL(debug) << "    The solution has converged err = " << err << " < " << _eps_converge << " ( res = " << _rms_res << " ) istep = " << _istep_vcycle << "\n" << std::endl;
       }
       converged = Exit_Status::SUCCESS;
     } else {
       if(_verbose){
        BOOST_LOG_TRIVIAL(debug) << "    The solution has not yet converged err = " << err << " !< " << _eps_converge << std::endl;
       }
     }
   }
 
   if(_verbose && (_rms_res > _rms_res_old && _istep_vcycle > 1) ){
     BOOST_LOG_TRIVIAL(debug) << "    Warning: Residual_old > Residual" << std::endl;
   }
 
   // Define converged if istep exceeds maxsteps to avoid infinite loop...
   if(_istep_vcycle >= _maxsteps){
     BOOST_LOG_TRIVIAL(debug) << "    WARNING: MultigridSolver failed to converge! Reached istep = maxsteps = " << _maxsteps << std::endl;
     BOOST_LOG_TRIVIAL(debug) << "    res = " << _rms_res << " res_old = " << _rms_res_old << " res_i = " << _rms_res_i << std::endl;
     converged  = Exit_Status::MAX_STEPS;
   }
 
   return converged;
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::check_solution	(	size_t	level,
		Grid< NDIM, T > &	sol
	)

virtual

Definition at line 370 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< NDIM, T >::check_solution(), MultiGridSolver< 3, T >::get_multigrid_source(), MultiGridSolver< NDIM, T >::recursive_go_down(), and MultiGridSolver< NDIM, T >::recursive_go_up().

370 { }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::check_solution ( size_t level )

Definition at line 373 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::check_solution(), and MultiGridSolver< NDIM, T >::get_grid().

373 { check_solution(level, get_grid(level)); }

MultiGridSolver::get_grid

Grid< NDIM, T > & get_grid(size_t level=0)

Definition: multigrid_solver.h:122

MultiGridSolver::check_solution

virtual void check_solution(size_t level, Grid< NDIM, T > &sol)

Definition: multigrid_solver.cpp:370

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::clear ( )

Definition at line 644 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_ext_field, MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_N, MultiGridSolver< NDIM, T >::_Nlevel, MultiGridSolver< NDIM, T >::_Ntot, MultiGridSolver< NDIM, T >::_res, MultiGridSolver< NDIM, T >::_res_domain_array, and MultiGridSolver< NDIM, T >::_source.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source(), and main().

                                      {
   _N = _Ntot = _Nlevel = 0;
   _f.clear();
   _res.clear();
   _source.clear();
   _ext_field.clear();
   _res_domain_array.clear();
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::correct_sol	(	Grid< NDIM, T > &	f,
		const Grid< NDIM, T > &	corr,
		const size_t	level
	)

virtual

Definition at line 565 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source(), and MultiGridSolver< NDIM, T >::recursive_go_up().

 {
     f += corr;
 }

template<size_t NDIM, typename T>

T MultiGridSolver< NDIM, T >::dl_operator	(	const size_t	level,
		const std::vector< size_t > &	index_list,
		const T	h
	)		const

virtual

Reimplemented in anonymous_namespace{chameleon.cpp}::ChiSolver< T >.

Definition at line 56 of file multigrid_solver.cpp.

References ccl_test_distances::h, and growth_allz::T.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source().

 {
   // The derivtive dL/df
   T dl = -2.0*NDIM/(h*h);
 
   // Sanity check
   if(fabs(dl) < 1e-10){
     BOOST_LOG_TRIVIAL(error) << "Error: dl close to 0" << std::endl;
     exit(1);
   }
 
   return dl;
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::GaussSeidelSweep	(	size_t	level,
		size_t	curcolor,
		T *	f
	)

private

Definition at line 444 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_ngridcolours, MultiGridSolver< NDIM, T >::get_N(), MultiGridSolver< NDIM, T >::get_neighbor_gridindex(), MultiGridSolver< NDIM, T >::get_Ntot(), ccl_test_distances::h, growth_allz::T, and MultiGridSolver< NDIM, T >::upd_operator().

Referenced by MultiGridSolver< NDIM, T >::solve_current_level().

                                                                                  {
   size_t N    = get_N(level);
   size_t Ntot = get_Ntot(level);
 
   // Gridspacing
   const T h = 1.0/T( get_N(level) );
 
 #ifdef OPENMP
 #pragma omp parallel for 
 #endif
   for (size_t i = 0; i < Ntot; i++) {
     // Compute cell-color
     size_t color = 0;
     for(size_t j = 0, n = 1; j < NDIM; j++, n *= N){
       color += ( i / n % N );
     }
     color = color % _ngridcolours;
 
     // Only select cells with right color
     if( color == curcolor ){
 
       // Update the solution f = f - L / (dL/df)
       std::vector<size_t> index_list;
       get_neighbor_gridindex(index_list, i, N);
       f[i] = upd_operator(f[i], level, index_list, h);
     }
   }
 }

template<size_t NDIM, typename T>

T* MultiGridSolver< NDIM, T >::get_external_field	(	size_t	level,
		size_t	field
	)

inline

Definition at line 129 of file multigrid_solver.h.

Referenced by ContinuitySolver< NDIM, T >::dl_operator(), PoissonSolver< NDIM, T >::l_operator(), ContinuitySolver< NDIM, T >::l_operator(), and FofrSolver< NDIM, T >::l_operator().

129 { return _ext_field[field]->get_y(level); };

MultiGridSolver::_ext_field

std::vector< MultiGrid< NDIM, T > * > _ext_field

Definition: multigrid_solver.h:63

template<size_t NDIM, typename T>

T const* MultiGridSolver< NDIM, T >::get_external_field	(	size_t	level,
		size_t	field
	)		const

inline

Definition at line 130 of file multigrid_solver.h.

130 { return _ext_field[field]->get_y(level); };

MultiGridSolver::_ext_field

std::vector< MultiGrid< NDIM, T > * > _ext_field

Definition: multigrid_solver.h:63

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::get_external_field_size ( ) const

inline

Definition at line 135 of file multigrid_solver.h.

135 { return _ext_field.size(); };

MultiGridSolver::_ext_field

std::vector< MultiGrid< NDIM, T > * > _ext_field

Definition: multigrid_solver.h:63

template<size_t NDIM, typename T>

Grid<NDIM, T>& MultiGridSolver< NDIM, T >::get_external_grid	(	size_t	level,
		size_t	field
	)

inline

Definition at line 132 of file multigrid_solver.h.

132 { return _ext_field[field]->get_grid(level); };

MultiGridSolver::_ext_field

std::vector< MultiGrid< NDIM, T > * > _ext_field

Definition: multigrid_solver.h:63

template<size_t NDIM, typename T>

const Grid<NDIM, T>& MultiGridSolver< NDIM, T >::get_external_grid	(	size_t	level,
		size_t	field
	)		const

inline

Definition at line 133 of file multigrid_solver.h.

133 { return _ext_field[field]->get_grid(level); };

MultiGridSolver::_ext_field

std::vector< MultiGrid< NDIM, T > * > _ext_field

Definition: multigrid_solver.h:63

template<size_t NDIM, typename T>

Grid<NDIM, T>& MultiGridSolver< NDIM, T >::get_grid ( size_t level = 0 )

inline

Definition at line 122 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_solution(), main(), and anonymous_namespace{chameleon.cpp}::transform_MultiGridSolver_to_Mesh().

122 { return _f.get_grid(level); };

MultiGridSolver::_f

MultiGrid< NDIM, T > _f

Definition: multigrid_solver.h:57

template<size_t NDIM, typename T>

const Grid<NDIM, T>& MultiGridSolver< NDIM, T >::get_grid ( size_t level = 0 ) const

inline

Definition at line 123 of file multigrid_solver.h.

123 { return _f.get_grid(level); };

MultiGridSolver::_f

MultiGrid< NDIM, T > _f

Definition: multigrid_solver.h:57

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::get_istep ( ) const

inline

Definition at line 116 of file multigrid_solver.h.

116 { return _istep_vcycle; };

MultiGridSolver::_istep_vcycle

size_t _istep_vcycle

Definition: multigrid_solver.h:96

template<size_t NDIM, typename T>

MultiGrid<NDIM, T>& MultiGridSolver< NDIM, T >::get_mlt_grid ( size_t level = 0 )

inline

Definition at line 125 of file multigrid_solver.h.

125 { return _f; };

MultiGridSolver::_f

MultiGrid< NDIM, T > _f

Definition: multigrid_solver.h:57

template<size_t NDIM, typename T>

const MultiGrid<NDIM, T>& MultiGridSolver< NDIM, T >::get_mlt_grid ( size_t level = 0 ) const

inline

Definition at line 126 of file multigrid_solver.h.

126 { return _f; };

MultiGridSolver::_f

MultiGrid< NDIM, T > _f

Definition: multigrid_solver.h:57

template<size_t NDIM, typename T>

T MultiGridSolver< NDIM, T >::get_multigrid_source	(	size_t	level,
		size_t	i
	)		const

inline

Definition at line 138 of file multigrid_solver.h.

Referenced by PoissonSolver< NDIM, T >::l_operator(), ContinuitySolver< NDIM, T >::l_operator(), and FofrSolver< NDIM, T >::l_operator().

138 { return _source[level][i]; };

MultiGridSolver::_source

MultiGrid< NDIM, T > _source

Definition: multigrid_solver.h:59

template<size_t NDIM, typename T >

size_t MultiGridSolver< NDIM, T >::get_N ( size_t level = 0 ) const

Definition at line 194 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< NDIM, T >::calculate_residual(), MultiGridSolver< NDIM, T >::GaussSeidelSweep(), MultiGridSolver< 3, T >::get_multigrid_source(), main(), MultiGridSolver< NDIM, T >::make_new_source(), and MultiGridSolver< NDIM, T >::prolonge_up_array().

                                                         { 
   return _f.get_N(level); 
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::get_neighbor_gridindex	(	std::vector< size_t > &	index_list,
		size_t	i,
		size_t	ngrid
	)

protected

Definition at line 263 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< NDIM, T >::calculate_residual(), MultiGridSolver< NDIM, T >::GaussSeidelSweep(), and MultiGridSolver< NDIM, T >::make_new_source().

                                                                                                      {
   index_list = std::vector<size_t>(2*NDIM+1);
   index_list[0] = i;
   for(size_t j = 0, n = 1; j < NDIM; j++, n *= N){
     size_t ii = i/n % N;
     size_t iminus = ii >= 1   ? ii - 1 : N - 1;
     size_t iplus  = ii <= N-2 ? ii + 1 : 0;
     index_list[2*j+1] = i + (iminus - ii) * n;
     index_list[2*j+2] = i + (iplus - ii) * n;
   }
 }

template<size_t NDIM, typename T >

size_t MultiGridSolver< NDIM, T >::get_Nlevel ( ) const

Definition at line 204 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source().

                                                  { 
   return _Nlevel;
 }

template<size_t NDIM, typename T >

size_t MultiGridSolver< NDIM, T >::get_Ntot ( size_t level = 0 ) const

Definition at line 199 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< NDIM, T >::calculate_residual(), MultiGridSolver< NDIM, T >::GaussSeidelSweep(), MultiGridSolver< 3, T >::get_multigrid_source(), MultiGridSolver< NDIM, T >::make_new_source(), and MultiGridSolver< NDIM, T >::prolonge_up_array().

                                                            { 
   return _f.get_Ntot(level); 
 }

template<size_t NDIM, typename T >

T * MultiGridSolver< NDIM, T >::get_y ( size_t level = 0 )

Definition at line 145 of file multigrid_solver.cpp.

Referenced by FofrSolver< NDIM, T >::dl_operator(), MultiGridSolver< 3, T >::get_istep(), PoissonSolver< NDIM, T >::l_operator(), ContinuitySolver< NDIM, T >::l_operator(), and FofrSolver< NDIM, T >::l_operator().

                                              { 
   return _f.get_y(level);
 }

template<size_t NDIM, typename T >

T const * MultiGridSolver< NDIM, T >::get_y ( size_t level = 0 ) const

Definition at line 150 of file multigrid_solver.cpp.

                                                           {
     return _f.get_y(level);
 } 

template<size_t NDIM, typename T>

T MultiGridSolver< NDIM, T >::l_operator	(	const size_t	level,
		const std::vector< size_t > &	index_list,
		bool	addsource,
		const T	h
	)		const

virtual

Reimplemented in anonymous_namespace{chameleon.cpp}::ChiSolver< T >.

Definition at line 24 of file multigrid_solver.cpp.

References ccl_test_distances::h, cl_cmbl_bm::l, and growth_allz::T.

Referenced by MultiGridSolver< NDIM, T >::calculate_residual(), MultiGridSolver< 3, T >::get_multigrid_source(), and MultiGridSolver< NDIM, T >::make_new_source().

 {
   T l, source, kinetic;
   size_t i = index_list[0];
 
   // Compute the standard kinetic term [D^2 f]
   kinetic = -2.0 * NDIM * _f[level][ i ];
   for(size_t k = 1; k < 2*NDIM + 1; k++){
     kinetic += _f[level][ index_list[k] ];
   }
 
   // The right hand side of the PDE
   T *rho = _ext_field[0]->get_y(level);
   source = rho[i];
 
   // Add the source term arising from restricting the equation down to the lower level
   if( level > 0 && addsource ){
     source += _source[level][i];
   }
 
   // The full equation
   l = kinetic/(h*h) - source;
 
   return l;
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::make_new_source ( size_t level )

private

Definition at line 588 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_res, MultiGridSolver< NDIM, T >::_source, MultiGridSolver< NDIM, T >::get_N(), MultiGridSolver< NDIM, T >::get_neighbor_gridindex(), MultiGridSolver< NDIM, T >::get_Ntot(), ccl_test_distances::h, MultiGridSolver< NDIM, T >::l_operator(), and growth_allz::T.

Referenced by MultiGridSolver< NDIM, T >::recursive_go_down().

                                                          {
   size_t N    = get_N(level);
   size_t Ntot = get_Ntot(level);
 
   // Gridspacing
   const T h = 1.0/T( get_N(level) );
 
   // Calculate the new source
 #ifdef OPENMP
 #pragma omp parallel for
 #endif
   for(size_t i = 0; i < Ntot; i++){
     std::vector<size_t> index_list;
     get_neighbor_gridindex(index_list, i, N);
     T res = l_operator(level, index_list, false, h);
     _source[level][i] = _res[level][i] + res;
   }
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::make_prolongation_array	(	Grid< NDIM, T > &	f,
		Grid< NDIM, T > &	Rf,
		Grid< NDIM, T > &	df
	)

private

Definition at line 578 of file multigrid_solver.cpp.

References Grid< NDIM, T >::get_Ntot().

Referenced by MultiGridSolver< NDIM, T >::recursive_go_up().

                                                                                                         {
   size_t Ntot = f.get_Ntot();
   df = f - Rf;
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::prolonge_up_array	(	size_t	to_level,
		Grid< NDIM, T > &	BottomGrid,
		Grid< NDIM, T > &	TopGrid
	)

private

Definition at line 381 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::get_N(), MultiGridSolver< NDIM, T >::get_Ntot(), m, and growth_allz::T.

Referenced by MultiGridSolver< NDIM, T >::recursive_go_up().

                                                                                                        {
   size_t twotondim = 1 << NDIM;
   size_t NTop      = get_N(to_level);
   size_t NtotTop   = get_Ntot(to_level);
   size_t NBottom   = NTop/2;
   
   // Compute NTop, Ntop^2, ... , Ntop^{Ndim-1} and similar for Nbottom
   std::vector<size_t> nBottomPow(NDIM, 1);
   std::vector<size_t> nTopPow(NDIM, 1);
   for(size_t j = 0, n = 1, m = 1; j < NDIM; j++, n *= NBottom, m *= NTop){
     nBottomPow[j] = n;
     nTopPow[j] = m;
   }
 
   // Trilinear prolongation
 #ifdef OPENMP
 #pragma omp parallel for  
 #endif
   for (size_t i = 0; i < NtotTop; i++) {
     std::vector<double> fac(NDIM, 0.0);
     std::vector<int> iplus(NDIM, 0);
 
     double norm = 1.0;
     int iBottom = 0;
 
     // Compute the shift in index from iBottom to the cells corresponding to ix -> ix+1
     // The fac is the weight for the trilinear interpolation
     for(size_t j = 0; j < NDIM; j++){
       size_t ii = i/nTopPow[j] % NTop;
       size_t iiBottom = ii/2;
       iplus[j] = (iiBottom == NBottom-1 ? 1 - NBottom : 1) * nBottomPow[j];
       fac[j]   = ii % 2 == 0 ? 0.0 : 1.0;
       iBottom += iiBottom * nBottomPow[j];
       norm    *= (1.0 + fac[j]);
     }
 
     // Compute the sum Top[i] = Sum fac_i             * Top[iBottom + d_i] 
     //                        + Sum fac_i fac_j       * Top[iBottom + d_i + d_j] 
     //                        + Sum fac_i fac_j fac_k * Top[iBottom + d_i + d_j + d_k]
     //                        + ... +
     //                        + fac_1 ... fac_NDIM * Top[iBottom + d_1 + ... + d_NDIM]
     Top[i] = Bottom[iBottom];
     for(size_t k = 1; k < twotondim; k++){
       double termfac = 1.0;
       int iAdd = 0;
       std::bitset<NDIM> bits = std::bitset<NDIM>(k);
       for(size_t j = 0; j < NDIM; j++){
         iAdd = bits[j] * iplus[j];
         termfac *= 1.0 + bits[j] * (fac[j] - 1.0) ;
       }
       Top[i] += T(termfac) * Bottom[iBottom + iAdd];
     }
     Top[i] *= 1.0/T(norm);
   }
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::recursive_go_down ( size_t from_level )

private

Definition at line 612 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_Nlevel, MultiGridSolver< NDIM, T >::_res, MultiGridSolver< NDIM, T >::_verbose, MultiGridSolver< NDIM, T >::check_solution(), MultiGridSolver< NDIM, T >::make_new_source(), and MultiGridSolver< NDIM, T >::solve_current_level().

                                                                 {
   size_t to_level = from_level + 1;
 
   // Check if we are at the bottom
   if(to_level >= _Nlevel) {
     if(_verbose) {
       BOOST_LOG_TRIVIAL(debug) << "    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << std::endl;
       BOOST_LOG_TRIVIAL(debug) << "    We have reached the bottom level = " << from_level << " Start going up." << std::endl;
       BOOST_LOG_TRIVIAL(debug) << "    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n" << std::endl;
     }
     return;
   }
   
   if(_verbose)
     BOOST_LOG_TRIVIAL(debug) << "    Going down from level " << from_level << " -> " << to_level << std::endl;
 
   // Restrict residual and solution
   _res.restrict_down(from_level, _res.get_grid(to_level));
   _f.restrict_down(from_level, _f.get_grid(to_level));
   check_solution(to_level);
 
   // Make new source
   make_new_source(to_level);
 
   // Solve on current level
   solve_current_level(to_level);
 
   // Recursive call
   recursive_go_down(to_level);
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::recursive_go_up ( size_t to_level )

private

Definition at line 532 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_res, MultiGridSolver< NDIM, T >::_verbose, MultiGridSolver< NDIM, T >::calculate_residual(), MultiGridSolver< NDIM, T >::check_solution(), MultiGridSolver< NDIM, T >::correct_sol(), MultiGridSolver< NDIM, T >::make_prolongation_array(), MultiGridSolver< NDIM, T >::prolonge_up_array(), and MultiGridSolver< NDIM, T >::solve_current_level().

                                                             {
   size_t from_level = to_level + 1;
 
   // Restrict down R[f] and store in _res (used as temp-array)
   _f.restrict_down(to_level, _res.get_grid(from_level));
   check_solution(from_level, _res.get_grid(from_level));
 
   // Make prolongation array ready at from_level
   make_prolongation_array(_f.get_grid(from_level), _res.get_grid(from_level), _res.get_grid(from_level));
 
   // Prolonge up solution from-level to to-level and store in _res (used as temp array)
   if(_verbose)
     BOOST_LOG_TRIVIAL(debug) << "    Prolonge solution from level: " << to_level+1 << " -> " << to_level << std::endl;
   prolonge_up_array(to_level, _res.get_grid(from_level), _res.get_grid(to_level));
 
   // Correct solution at to_level (temp array _res contains the correction P[f-R[f]])
   correct_sol(_f.get_grid(to_level), _res.get_grid(to_level), to_level);
 
   // Calculate new residual
   calculate_residual(to_level, _res.get_grid(to_level));
 
   // Solve on the level we just went up to
   solve_current_level(to_level);
 
   // Continue going up
   if(to_level > 0)
     recursive_go_up(to_level-1);
   else {
     return;
   }
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::set_convergence_criterion_residual ( bool use_residual )

Definition at line 171 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source().

                                                                                  {
   _conv_criterion_residual = use_residual;
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::set_epsilon ( double eps_converge )

Definition at line 155 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source(), and main().

                                                             { 
   _eps_converge = eps_converge; 
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::set_initial_guess ( T guess )

Definition at line 231 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_Ntot, and growth_allz::T.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source(), and main().

                                                       {
   T *f = _f.get_y(0);
   std::fill_n(f, _Ntot, guess);
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::set_initial_guess ( T * guess )

Definition at line 237 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_Ntot, and growth_allz::T.

                                                        {
   T *f = _f.get_y(0);
   std::copy( &guess[0], &guess[0] + _Ntot, &f[0] );
 }

template<size_t NDIM, typename T>

void MultiGridSolver< NDIM, T >::set_initial_guess ( Grid< NDIM, T > & guess )

Definition at line 243 of file multigrid_solver.cpp.

References MultiGridSolver< NDIM, T >::_f, MultiGridSolver< NDIM, T >::_Ntot, Grid< NDIM, T >::get_y(), and growth_allz::T.

                                                                       {
   T *f = _f.get_y(0);
   T *guess = guessgrid.get_y();
   std::copy( &guess[0], &guess[0] + _Ntot, &f[0] );
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::set_maxsteps ( size_t maxsteps )

Definition at line 166 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source().

                                                          { 
   _maxsteps = maxsteps; 
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::set_ngs_sweeps	(	size_t	ngs_fine,
		size_t	ngs_coarse
	)

Definition at line 176 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source(), and main().

                                                                               {
   _ngs_fine = ngs_fine; 
   _ngs_coarse = ngs_coarse; 
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::set_Nlevel ( size_t N )

Definition at line 182 of file multigrid_solver.cpp.

References power().

Referenced by MultiGridSolver< 3, T >::get_multigrid_source().

                                                 {
     // Check that N is divisible by 2^{Nlevel - 1} which is required for the restriction to make sense
     assert( ( _N / power(2, N - 1) ) * power(2, N - 1) == _N); 
 
     // We should have atleast 1 level
     assert(N >= 1); 
 
     // set new _Nlevel
     _Nlevel = N;
 }

template<size_t NDIM, typename T >

MultiGridSolver< NDIM, T >::Exit_Status MultiGridSolver< NDIM, T >::solve ( )

Definition at line 89 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< 3, T >::get_multigrid_source(), and main().

                                                                           {
   // Init some variables
   _istep_vcycle = 0;
   _tot_sweeps_domain_grid = 0;
   _res_domain_array.clear();
 
   if(_verbose){
     BOOST_LOG_TRIVIAL(debug) << std::endl;
     BOOST_LOG_TRIVIAL(debug) << "===============================================================" << std::endl;
     BOOST_LOG_TRIVIAL(debug) << "==> Starting multigrid solver" << std::endl;
     BOOST_LOG_TRIVIAL(debug) << "===============================================================\n" << std::endl;
   }
 
   // Pre-solve on domaingrid
   solve_current_level(0);
 
   // Set the initial residual 
   _rms_res_i = _rms_res;
   _rms_res_old = 0.0;
 
   // Check if we already have convergence
   Exit_Status status = check_convergence();
 
   // The V-cycle
   while(status == Exit_Status::ITERATE) {
     ++_istep_vcycle;
     
     if(_verbose){
       BOOST_LOG_TRIVIAL(debug) << std::endl;
       BOOST_LOG_TRIVIAL(debug) << "===============================================================" << std::endl;
       BOOST_LOG_TRIVIAL(debug) << "==> Starting V-cycle istep = " << _istep_vcycle << " Res = " << _rms_res << std::endl;
       BOOST_LOG_TRIVIAL(debug) << "===============================================================\n" << std::endl;
     }
 
     if (_Nlevel == 1)
         // no V-cycle, solve on domaingrid
         solve_current_level(0);
     else
     {// Go down to the bottom (from finest grid [0] to coarsest grid [_Nlevel-1])
         recursive_go_down(0);
 
         // Go up to the top
         recursive_go_up(_Nlevel-2);
     }
 
     // Check for errors in the computation (NaN) and exit if true
     _f.get_grid(0).check_for_nan(true);
     
     // Check for convergence
     status = check_convergence();
   }
 
   return status;
 }

template<size_t NDIM, typename T >

void MultiGridSolver< NDIM, T >::solve_current_level ( size_t level )

private

Definition at line 478 of file multigrid_solver.cpp.

Referenced by MultiGridSolver< NDIM, T >::recursive_go_down(), and MultiGridSolver< NDIM, T >::recursive_go_up().

                                                              {
   size_t ngs_sweeps;
  
   if(_verbose)
     BOOST_LOG_TRIVIAL(debug) << "    Performing Newton-Gauss-Seidel sweeps at level " << level << std::endl;
 
   // Number of sweeps we do
   if(level == 0)
     ngs_sweeps = _ngs_fine;
   else
     ngs_sweeps = _ngs_coarse;
 
   // Do N Gauss-Seidel Sweeps
   for (size_t i = 0; i < ngs_sweeps; i++) {
     if(level == 0)
       ++_tot_sweeps_domain_grid;
 
     // Sweep through grid according to sum of coord's mod _ngridcolours
     // Standard is _ngridcolours = 2 -> chess-board ordering
     for(size_t j = 0; j < _ngridcolours; j++)
       GaussSeidelSweep(level, j, _f[level]);
 
     // Calculate residual and output quite often.
     // For debug, but this is quite useful so keep it for now
     if(_verbose){
       if( (level > 0 && (i == 1 || i == ngs_sweeps-1) ) || (level == 0) ){
         BOOST_LOG_TRIVIAL(debug) << "        level = " << std::setw(5) << level << " NGS Sweep = " << std::setw(5) << i;
         BOOST_LOG_TRIVIAL(debug) << " Residual = " << std::setw(10) << calculate_residual(level, _res.get_grid(level)) << std::endl;
       }
     }
 
     // Compute and store the residual after every sweep on the domaingrid
     if(level == 0 && _store_all_residual){
       _res_domain_array.push_back( calculate_residual(level, _res.get_grid(level)) );
     }
   }
   if(_verbose) BOOST_LOG_TRIVIAL(debug) << std::endl;
 
   // Compute the residual
   double curres = calculate_residual(level, _res.get_grid(level));
 
   // Store domaingrid residual
   if (level == 0){
     _rms_res_old = _rms_res;
     _rms_res = curres;
   }
 
 }

template<size_t NDIM, typename T>

T MultiGridSolver< NDIM, T >::upd_operator	(	const T	f,
		const size_t	level,
		const std::vector< size_t > &	index_list,
		const T	h
	)		const

virtual

Reimplemented in anonymous_namespace{chameleon.cpp}::ChiSolver< T >.

Definition at line 77 of file multigrid_solver.cpp.

References cl_cmbl_bm::l, and growth_allz::T.

Referenced by MultiGridSolver< NDIM, T >::GaussSeidelSweep(), and MultiGridSolver< 3, T >::get_multigrid_source().

 {
     T l  =  l_operator(level, index_list, true, h);
     T dl = dl_operator(level, index_list, h);
     return f - l/dl;
 }

Member Data Documentation

template<size_t NDIM, typename T>

bool MultiGridSolver< NDIM, T >::_conv_criterion_residual = true

protected

Definition at line 93 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence().

template<size_t NDIM, typename T>

double MultiGridSolver< NDIM, T >::_eps_converge = 1e-5

protected

Definition at line 94 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence().

template<size_t NDIM, typename T>

std::vector<MultiGrid<NDIM,T> * > MultiGridSolver< NDIM, T >::_ext_field

private

Definition at line 63 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear().

template<size_t NDIM, typename T>

MultiGrid<NDIM, T> MultiGridSolver< NDIM, T >::_f

private

Definition at line 57 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), MultiGridSolver< 3, T >::get_mlt_grid(), MultiGridSolver< NDIM, T >::MultiGridSolver(), MultiGridSolver< NDIM, T >::recursive_go_down(), MultiGridSolver< NDIM, T >::recursive_go_up(), MultiGridSolver< NDIM, T >::set_initial_guess(), and MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_istep_vcycle = 0

protected

Definition at line 96 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence(), and MultiGridSolver< 3, T >::get_istep().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_maxsteps = 1000

protected

Definition at line 95 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_N

private

Definition at line 51 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), and MultiGridSolver< NDIM, T >::MultiGridSolver().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_ngridcolours = 2

private

Definition at line 68 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::GaussSeidelSweep(), and MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_ngs_coarse = 2

private

Definition at line 66 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_ngs_fine = 2

private

Definition at line 67 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_Nlevel

private

Definition at line 54 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), MultiGridSolver< NDIM, T >::MultiGridSolver(), and MultiGridSolver< NDIM, T >::recursive_go_down().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_Nmin

private

Definition at line 53 of file multigrid_solver.h.

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_Ntot

private

Definition at line 52 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), and MultiGridSolver< NDIM, T >::set_initial_guess().

template<size_t NDIM, typename T>

MultiGrid<NDIM, T> MultiGridSolver< NDIM, T >::_res

private

Definition at line 58 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), MultiGridSolver< NDIM, T >::make_new_source(), MultiGridSolver< NDIM, T >::MultiGridSolver(), MultiGridSolver< NDIM, T >::recursive_go_down(), MultiGridSolver< NDIM, T >::recursive_go_up(), and MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

std::vector<double> MultiGridSolver< NDIM, T >::_res_domain_array

Definition at line 108 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), and MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

double MultiGridSolver< NDIM, T >::_rms_res

protected

Definition at line 99 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence(), and MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

double MultiGridSolver< NDIM, T >::_rms_res_i

protected

Definition at line 100 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence().

template<size_t NDIM, typename T>

double MultiGridSolver< NDIM, T >::_rms_res_old

protected

Definition at line 101 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence(), and MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

MultiGrid<NDIM, T> MultiGridSolver< NDIM, T >::_source

private

Definition at line 59 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::clear(), MultiGridSolver< NDIM, T >::make_new_source(), and MultiGridSolver< NDIM, T >::MultiGridSolver().

template<size_t NDIM, typename T>

bool MultiGridSolver< NDIM, T >::_store_all_residual = false

Definition at line 107 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

size_t MultiGridSolver< NDIM, T >::_tot_sweeps_domain_grid = 0

private

Definition at line 72 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::solve_current_level().

template<size_t NDIM, typename T>

bool MultiGridSolver< NDIM, T >::_verbose

protected

Definition at line 87 of file multigrid_solver.h.

Referenced by MultiGridSolver< NDIM, T >::check_convergence(), MultiGridSolver< NDIM, T >::recursive_go_down(), MultiGridSolver< NDIM, T >::recursive_go_up(), and MultiGridSolver< NDIM, T >::solve_current_level().

The documentation for this class was generated from the following files:

src/3party/MultiGridSolver/src/multigrid_solver.h
src/3party/MultiGridSolver/src/multigrid_solver.cpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

template<size_t NDIM, typename T> class MultiGridSolver< NDIM, T >

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<size_t NDIM, typename T>
class MultiGridSolver< NDIM, T >