block_matrix_application.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2009 by Guido Kanschat
// Copyright (C) 2006-2014 by Energy Systems Design Laboratory, University of Alberta
//
// This software is distributed under the MIT License
// For more information, see the README file in /doc/LICENSE
//
// - Class: block_matrix_application.h
// - Description:
// - Developers: Guido Kanschat, Texas A&M University
//               Marc Secanell,  University of Alberta
// - Id: $Id: block_matrix_application.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FUEL_CELL_APPLICATION_CORE_BLOCK_MATRIX_APPLICATION_H_
#define _FUEL_CELL_APPLICATION_CORE_BLOCK_MATRIX_APPLICATION_H_

#include <base/quadrature.h>
#include <lac/full_matrix.h>
#include <lac/block_sparse_matrix.h>
#include <lac/block_sparsity_pattern.h>
#include <lac/solver_bicgstab.h>
#include <lac/solver_cg.h>
#include <lac/vector.h>
#include <grid/tria.h>
#include <grid/tria_iterator.h>
#include <grid/tria_accessor.h>
#include <dofs/dof_tools.h>
#include <numerics/matrix_tools.h>
#include <base/parameter_handler.h>
#include <base/quadrature_lib.h>
#include <dofs/dof_handler.h>
#include <fe/fe.h>
#include <fe/fe_values.h>


#include <lac/petsc_solver.h>
#include <lac/petsc_parallel_block_sparse_matrix.h>
#include <lac/petsc_precondition.h>

#include "system_management.h"
#include "dof_application.h"
#include "matrix_block.h"
#include "linear_solvers.h"

namespace FuelCell
{
    namespace ApplicationCore
    {
        template <int dim>
        class BlockMatrixApplication :
        public DoFApplication<dim>
        {
        public:


            BlockMatrixApplication(boost::shared_ptr<ApplicationData> data =
            boost::shared_ptr<ApplicationData>());
            
            BlockMatrixApplication(DoFApplication<dim>&,
                                   bool triangulation_only);
            
            void _initialize(ParameterHandler& param);
            
            virtual void declare_parameters(ParameterHandler& param);
            virtual void initialize (ParameterHandler& param);

            #ifdef OPENFCST_WITH_PETSC
            void PETSc_assemble(const FEVectors&);
            #else
            void serial_assemble(const FEVectors&);
            #endif




            virtual void post_cell_assemble();
            


            void remesh_matrices();
            virtual void remesh();
            
            void assemble(const FEVectors&);
            
            
            void assemble_numerically(const FEVectors& src,
                                      const double delta = 1e-6);
            
            void residual_constraints(FEVector& dst) const;

            #ifdef OPENFCST_WITH_PETSC
            void residual_constraints(PETScWrappers::MPI::Vector& dst, const std::vector<unsigned int>& idx_list) const;
            #endif
            


            virtual void cell_matrix(MatrixVector& cell_matrices,
                                     const typename DoFApplication<dim>::CellInfo& cell);
            
            virtual void bdry_matrix(MatrixVector& face_matrices,
                                     const typename DoFApplication<dim>::FaceInfo& face);
            
            virtual void face_matrix(MatrixVector& matrices11,
                                     MatrixVector& matrices12,
                                     MatrixVector& matrices21,
                                     MatrixVector& matrices22,
                                     const typename DoFApplication<dim>::FaceInfo& face1,
                                     const typename DoFApplication<dim>::FaceInfo& face2);
            

            virtual void dirichlet_bc(std::map<unsigned int, double>& boundary_values) const;
            
            virtual void solve(FEVector&        dst,
                                          const FEVectors& src);

            #ifdef OPENFCST_WITH_PETSC
            void PETSc_solve(FuelCell::ApplicationCore::FEVector system_rhs,
                    FEVector& solution, const FEVectors& src);
            #else
            void serial_solve(FuelCell::ApplicationCore::FEVector system_rhs,
                    FEVector& solution);
            #endif


      protected:
            boost::shared_ptr<Quadrature<dim> > quadrature_assemble_cell;
            
            boost::shared_ptr<Quadrature<dim-1> > quadrature_assemble_face;
            
            bool repair_diagonal;


            std::map<unsigned int, double> boundary_values;

        private:

            BlockSparsityPattern sparsities;
        
        
        protected:        


            #ifdef OPENFCST_WITH_PETSC
            PETScWrappers::MPI::SparseMatrix matrix;
            #else
            BlockSparseMatrix<double> matrix;
            #endif

            SolverControl solver_control;


            


            std::string solver_name;
            bool assemble_numerically_flag;
            bool mumps_additional_mem;
    };
    
}

}

#endif