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
//
// ----------------------------------------------------------------------------

#ifndef _FUEL_CELL_APPLICATION_CORE_BLOCK_MATRIX_APPLICATION_H_
#define _FUEL_CELL_APPLICATION_CORE_BLOCK_MATRIX_APPLICATION_H_

//-- dealII
#include <deal.II/base/quadrature.h>
#include <deal.II/lac/petsc_solver.h>
#include <deal.II/lac/petsc_parallel_block_sparse_matrix.h>
#include <deal.II/lac/petsc_precondition.h>
#include <deal.II/lac/block_sparsity_pattern.h>
#include <deal.II/lac/solver_bicgstab.h>
#include <deal.II/lac/solver_cg.h>
#include <deal.II/numerics/matrix_tools.h>
#include <deal.II/base/timer.h>

//--OpenFCST
#include <application_core/system_management.h>
#include <application_core/dof_application.h>
#include <application_core/matrix_block.h>
#include <solvers/linear_solvers.h>

//--boost libraries
#include <boost/filesystem.hpp>

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:
          
          template <typename Vector>
          void print_matrix_and_rhs(Vector& sys_rhs) const;
            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;
                   


            bool output_system_assembling_time;            
            
            Timer timer;
        
        protected:        


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

            SolverControl solver_control;


            


            bool assemble_numerically_flag;
            bool mumps_additional_mem;
            bool symmetric_matrix_flag;
            bool print_debug;
    };
    
}

}

#endif