block_matrix_application.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//    $Id: block_matrix_application.h 1415 2013-08-30 16:14:41Z secanell $
//
//    Copyright (C) 2006, 2007, 2008, 2009 by Guido Kanschat
//    Copyright (C) 2007-13 by Marc Secanell
//
//
//    This file is subject to QPL and may not be  distributed
//    without copyright and license information. Please refer
//    to the file deal.II/doc/license.html for the  text  and
//    further information on this license.
//
//---------------------------------------------------------------------------

#ifndef __deal2__appframe__block_matrix_application_h
#define __deal2__appframe__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/filtered_matrix.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 <appframe/dof_application.h>
#include <appframe/matrix_base.h>
#include <boost/shared_ptr.hpp>


namespace AppFrame
{
    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);  



        void add_vector_for_cell_matrix(std::string name,
                                        unsigned int block,
                                        unsigned int components,
                                        bool values,
                                        bool derivatives);
        
        void add_vector_for_flux_matrix(std::string name,
                                        unsigned int block,
                                        unsigned int components,
                                        bool values,
                                        bool derivatives);

        void do_assemble(
            const FEVectors&,
            typename DoFHandler<dim>::active_cell_iterator begin,
            typename DoFHandler<dim>::active_cell_iterator end,
            Threads::Mutex& mutex);
        
        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;
        



        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;
    
    protected:
        Table<2, DoFTools::Coupling> cell_couplings;
        
        Table<2, DoFTools::Coupling> flux_couplings;
        
        boost::shared_ptr<Quadrature<dim> > quadrature_assemble_cell;
        
        boost::shared_ptr<Quadrature<dim-1> > quadrature_assemble_face;

    private:
            BlockSparsityPattern sparsities;      
            
    protected:
        BlockSparseMatrix<double> matrix;
        FilteredMatrix<BlockVector<double> > filtered_matrix;
                
    private:
        MeshWorker::VectorSelector cell_matrix_values;
        MeshWorker::VectorSelector flux_matrix_values;    
   
    };
}
                    
#endif