matrix_application.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//    $Id: matrix_application.h 1348 2013-08-16 00:45:07Z secanell $
//
//    Copyright (C) 2006, 2007, 2008, 2009 by Guido Kanschat
//
//    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__matrix_application_h
#define __deal2__appframe__matrix_application_h

#include <base/quadrature.h>
#include <base/thread_management.h>
#include <base/multithread_info.h>
#include <lac/full_matrix.h>
#include <lac/sparse_matrix.h>
#include <lac/block_sparsity_pattern.h>
#include <grid/tria.h>
#include <grid/tria_iterator.h>
#include <grid/tria_accessor.h>
#include <dofs/dof_tools.h>
#include <base/mg_level_object.h>
#include <appframe/dof_application.h>
#include <appframe/matrix_base.h>
#include <boost/shared_ptr.hpp>

namespace AppFrame
{
  template <int dim>
  class MatrixApplication :
      public DoFApplication<dim>
  {
    public:
      typedef MatrixBlock<SparseMatrix<double> > MatrixType;
      typedef MatrixBlock<MGLevelObject<SparseMatrix<double> > > MGMatrixType;

      typedef MeshWorker::Assembler::MatrixLocalBlocksToGlobalBlocks<SparseMatrix<double> >
      Assembler;
      
      typedef MeshWorker::Assembler::MGMatrixLocalBlocksToGlobalBlocks<SparseMatrix<double> >
      MGAssembler;
      


      MatrixApplication(boost::shared_ptr<ApplicationData> data =
                        boost::shared_ptr<ApplicationData>(),
                        bool multigrid = false);

      MatrixApplication(bool multigrid);
      
      MatrixApplication(DoFApplication<dim>&,
                        bool triangulation_only,
                        bool multigrid = false);

      void _initialize(ParameterHandler& param);
      
      virtual void declare_parameters(ParameterHandler& param);

      virtual void initialize (ParameterHandler& param);


      
      void add_matrix(unsigned int row, unsigned int col);

      void add_mg_matrix(unsigned int row, unsigned int col);
      
      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);
      
      virtual void post_cell_assemble();


      
      void remesh_matrices();

      virtual void remesh();
 
      void assemble(const FEVectors&);


      
      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 mg_cell_matrix(MatrixVector& cell_matrices,
                                  const typename DoFApplication<dim>::CellInfo& cell);
      
      virtual void mg_bdry_matrix(MatrixVector& face_matrices,
                                  const typename DoFApplication<dim>::FaceInfo& face);
      
      virtual void mg_face_matrix(MatrixVector& matrices11,
                                  MatrixVector& matrices12,
                                  MatrixVector& matrices21,
                                  MatrixVector& matrices22,
                                  const typename DoFApplication<dim>::FaceInfo& face1,
                                  const typename DoFApplication<dim>::FaceInfo& face2);
      template <class ASSEMBLER>
      class LocalMatrixIntegrator : public ASSEMBLER,
                                    public MeshWorker::WorkerObjects::IntegrationWorker<dim>
      {
          SmartPointer<MatrixApplication<dim> > app;
          bool multigrid;
        public:
          LocalMatrixIntegrator(bool mg = false)
            : multigrid(mg)
            {}
          
          void initialize(MatrixApplication<dim>* a,
                          const MeshWorker::BlockInfo& bi, std::vector<typename ASSEMBLER::MatrixPtr>& m)
            {
              app = a;
              ASSEMBLER::initialize(bi, m);
            }
          
          void cell(const typename DoFApplication<dim>::CellInfo& cell)
            {
              if (multigrid)
                app->mg_cell_matrix(this->M11, cell);
              else
                app->cell_matrix(this->M11, cell);
              assemble(cell);
            }
          
          
          void bdry(const typename DoFApplication<dim>::FaceInfo& face)
            {
              if (multigrid)
                app->mg_bdry_matrix(this->M11, face);
              else
                app->bdry_matrix(this->M11, face);
              assemble(face);
            }
          
          void face(const typename DoFApplication<dim>::FaceInfo& face1,
                    const typename DoFApplication<dim>::FaceInfo& face2)
            {
              if (multigrid)
                app->mg_face_matrix(this->M11, this->M12, this->M21, this->M22, face1, face2);
              else
                app->face_matrix(this->M11, this->M12, this->M21, this->M22, face1, face2);
              assemble(face1, face2);
            }
      };
      
    protected:
      Table<2, DoFTools::Coupling> cell_couplings;
      
      Table<2, DoFTools::Coupling> flux_couplings;

      Table<2, DoFTools::Coupling> mg_cell_couplings;

      Table<2, DoFTools::Coupling> mg_flux_couplings;

      boost::shared_ptr<Quadrature<dim> > quadrature_assemble_cell;

      boost::shared_ptr<Quadrature<dim-1> > quadrature_assemble_face;
      
  private:
      BlockSparsityPattern sparsity;
      MGLevelObject<BlockSparsityPattern> mg_sparsity;
      
      MGLevelObject<BlockSparsityPattern> mg_sparsity_interface;
      
    protected:
      std::vector<boost::shared_ptr<MatrixType> > matrices;
      
      std::vector<boost::shared_ptr<MGMatrixType> > mg_matrices;

      std::vector<boost::shared_ptr<MGMatrixType> > mg_interface_matrices_up;
      
      std::vector<boost::shared_ptr<MGMatrixType> > mg_interface_matrices_down;
      
    private:
      MeshWorker::VectorSelector cell_matrix_values;
      
      MeshWorker::VectorSelector flux_matrix_values;
  };
  
}

#endif