solver.h

Go to the documentation of this file.

#ifndef solver_h
#define solver_h
 
#include <eigen3/Eigen/Dense>
#include "mesh.h"
 
template <int DIM_PROBLEM>
class solver
    {
    public:
        explicit solver(Mesh::mesh & _msh ,
                        std::vector<Tetra::prm> & _pTetra ,
                        std::vector<Facette::prm> & _pFac ,
                        const std::string name ,
                        const double _tol ,
                        const bool v ,
                        const int max_iter ):
                        msh(&_msh), NOD(_msh.getNbNodes()), paramTet(_pTetra),
                        paramFac(_pFac), verbose(v), iter(name,_tol,v,max_iter) {}
 
        virtual void checkBoundaryConditions(void) const = 0;
 
    protected:
        static const int DIM_PB = DIM_PROBLEM;
 
        Mesh::mesh *msh;
 
        const int NOD;
 
        const std::vector<Tetra::prm> &paramTet;
 
        const std::vector<Facette::prm> &paramFac;
 
        const bool verbose;
 
        algebra::iteration<double> iter;
 
        template <int N>
        void buildMat(std::vector<int> &ind, Eigen::Matrix<double,DIM_PROBLEM*N,DIM_PROBLEM*N> &Ke, algebra::w_sparseMat &K)
            {
            for (int ie=0; ie<N; ie++)
                {
                int i_ = ind[ie];
                for (int je=0; je<N; je++)
                    {
                    int j_ = ind[je];
                    for (int di=0; di<DIM_PROBLEM; di++)
                        for (int dj=0; dj<DIM_PROBLEM; dj++)
                            K.insert(DIM_PROBLEM*i_ + di, DIM_PROBLEM*j_ + dj, Ke(di*N+ie,dj*N+je));
                    }
                }
            }
 
        template <int N>
        void buildVect(std::vector<int> &ind, std::vector<double> &Le, std::vector<double> &L)
            {
            for (int ie=0; ie<N; ie++)
                {
                int i_ = ind[ie];
                for (int di=0; di<DIM_PROBLEM; di++)
                    { L[DIM_PROBLEM*i_ + di] += Le[di*N+ie]; }
                }
            }
    }; // end template class solver
 
#endif