mean_filter_assembler.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/base_header.hpp>
#include <kernel/lafem/mean_filter.hpp>
#include <kernel/assembly/linear_functional_assembler.hpp>
#include <kernel/assembly/interpolator.hpp>
#include <kernel/assembly/common_functionals.hpp>
#include <kernel/analytic/common.hpp>
 
namespace FEAT
{
  namespace Assembly
  {
    class MeanFilterAssembler
    {
    public:
      template<typename DataType_, typename IndexType_, typename Space_>
      static void assemble(
        LAFEM::DenseVector<DataType_, IndexType_>& vec_prim,
        LAFEM::DenseVector<DataType_, IndexType_>& vec_dual,
        const Space_& space, const String& cubature_name)
      {
        Cubature::DynamicFactory cubature_factory(cubature_name);
 
        assemble(vec_prim, vec_dual, space, cubature_factory);
      }
 
      template<typename DataType_, typename IndexType_, typename Space_>
      static void assemble(
        LAFEM::DenseVector<DataType_, IndexType_>& vec_prim,
        LAFEM::DenseVector<DataType_, IndexType_>& vec_dual,
        const Space_& space, const Cubature::DynamicFactory& cubature_factory)
      {
        // allocate primal and dual vectors
        vec_prim = LAFEM::DenseVector<DataType_, IndexType_>(space.get_num_dofs(), DataType_(0));
        vec_dual = LAFEM::DenseVector<DataType_, IndexType_>(space.get_num_dofs(), DataType_(0));
 
        // create a constant 1-function and its corresponding force functional
        Analytic::Common::ConstantFunction<Space_::world_dim, DataType_> one_func(DataType_(1));
        Assembly::Common::ForceFunctional<decltype(one_func)> one_force(one_func);
 
        // interpolate 1-function into vector v
        Assembly::Interpolator::project(vec_prim, one_func, space);
 
        // assemble 1-function force into vector w
        Assembly::LinearFunctionalAssembler::assemble_vector(vec_dual, one_force, space, cubature_factory);
      }
 
      template<typename DataType_, typename IndexType_, typename Space_>
      static void assemble(
        LAFEM::MeanFilter<DataType_, IndexType_>& filter,
        const Space_& space, const String& cubature_name,
        const DataType_ sol_mean = DataType_(0))
      {
        Cubature::DynamicFactory cubature_factory(cubature_name);
        assemble(filter, space, cubature_factory, sol_mean);
      }
 
      template<typename DataType_, typename IndexType_, typename Space_>
      static void assemble(
        LAFEM::MeanFilter<DataType_, IndexType_>& filter,
        const Space_& space, const Cubature::DynamicFactory& cubature_factory,
        const DataType_ sol_mean = DataType_(0))
      {
        // allocate primal and dual vectors
        LAFEM::DenseVector<DataType_, IndexType_> vec_prim, vec_dual;
 
        // assemble vectors
        assemble(vec_prim, vec_dual, space, cubature_factory);
 
        // create the filter
        filter = LAFEM::MeanFilter<DataType_, IndexType_>(std::move(vec_prim), std::move(vec_dual), sol_mean);
      }
    }; // class MeanFilterAssembler
  } // namespace Assembly
} // namespace FEAT