DirichletBC.h

/******************************************************************************
 *
 * AMDiS - Adaptive multidimensional simulations
 *
 * Copyright (C) 2013 Dresden University of Technology. All Rights Reserved.
 * Web: https://fusionforge.zih.tu-dresden.de/projects/amdis
 *
 * Authors:
 * Simon Vey, Thomas Witkowski, Andreas Naumann, Simon Praetorius, et al.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * This file is part of AMDiS
 *
 * See also license.opensource.txt in the distribution.
 *
 ******************************************************************************/



/** \file DirichletBC.h */

#ifndef AMDIS_DIRICHLETBC_H
#define AMDIS_DIRICHLETBC_H

#include "AMDiS_fwd.h"
#include "BoundaryCondition.h"
#include "AbstractFunction.h"
#include "FixVec.h"

namespace AMDiS
{

  // some tags used for tag-dispatching
  struct _value_by_abstractfunction {};
  struct _value_by_dofvector {};
  struct _value_by_function {};

  namespace detail
  {
    class DirichletBC : public BoundaryCondition
    {
    public:

      /// Constructor.
      DirichletBC(BoundaryType type,
		  const FiniteElemSpace *rowFeSpace,
		  const FiniteElemSpace *colFeSpace,
		  bool apply)
	: BoundaryCondition(type, rowFeSpace, colFeSpace),
	  applyBC(apply)
      { }

      /// Implementation of BoundaryCondition::fillBoundaryCondition().
      virtual void fillBoundaryCondition(DOFMatrix* matrix,
				ElInfo* elInfo,
				const DegreeOfFreedom* dofIndices,
				const BoundaryType* localBound,
				int nBasFcts) override;

      ///
      void initVector(DOFVectorBase<double>* vec);

      /// Implementation of BoundaryCondition::boundResidual().
      double boundResidual(ElInfo*,
			  DOFMatrix *,
			  const DOFVectorBase<double>*)
      {
	return 0.0;
      }

      /// Because this is a Dirichlet boundary condition, always return true.
      bool isDirichlet()
      {
	return true;
      }

      /// Returns \ref applyBC.
      bool applyBoundaryCondition()
      {
	return applyBC;
      }

    protected:

      /// Defines, if the boundary condition must be applied to the matrix. See
      /// comment of \ref BoundaryCondition::applyBoundaryCondition.
      bool applyBC;
    };

  } // end namespace detail




    /**
    * \ingroup Assembler
    *
    * \brief
    * Sub class of BoundaryCondition. Implements Dirichlet boundary conditions.
    * A DOFVectors is set to a given value at a Dirichlet dof and in a DOFMatrix
    * the row corresponding to a Dirichlet dof is replaced by a row containing
    * only a 1.0 in the diagonal.
    */
    template <class ValueTag>
    class DirichletBC {};

    // specialization for AbstractFunctions as value container
    template <>
    class DirichletBC<_value_by_abstractfunction> : public detail::DirichletBC
    {
      typedef detail::DirichletBC super;
    public:
      /// Constructor.
      DirichletBC(BoundaryType type,
		  AbstractFunction<double, WorldVector<double> > *fct,
		  const FiniteElemSpace *rowFeSpace,
		  const FiniteElemSpace *colFeSpace = NULL,
		  bool apply = true)
	: super(type, rowFeSpace, colFeSpace, apply),
	  container(*fct)
      { }


      /// Implementation of BoundaryCondition::fillBoundaryCondition().
      virtual void fillBoundaryCondition(DOFVectorBase<double>* vector,
				ElInfo* elInfo,
				const DegreeOfFreedom* dofIndices,
				const BoundaryType* localBound,
				int nBasFcts) override;

    protected:
      AbstractFunction<double, WorldVector<double> > &container;
    };


    // specialization for DOFVectors as value container
    template <>
    class DirichletBC<_value_by_dofvector> : public detail::DirichletBC
    {
      typedef detail::DirichletBC super;
    public:
      /// Constructor.
      DirichletBC(BoundaryType type,
		  DOFVectorBase<double> *vec,
		  bool apply = true);


      /// Implementation of BoundaryCondition::fillBoundaryCondition().
      virtual void fillBoundaryCondition(DOFVectorBase<double>* vector,
				ElInfo* elInfo,
				const DegreeOfFreedom* dofIndices,
				const BoundaryType* localBound,
				int nBasFcts) override;

    protected:
      DOFVectorBase<double> *container;
    };


#if AMDIS_HAS_CXX11
    // specialization for std::function or lambdas as value container
    template <>
    class DirichletBC<_value_by_function> : public detail::DirichletBC
    {
      typedef detail::DirichletBC super;
    public:
      /// Constructor.
      DirichletBC(BoundaryType type,
		  std::function<double(WorldVector<double>)> fct,
		  const FiniteElemSpace *rowFeSpace,
		  const FiniteElemSpace *colFeSpace = NULL,
		  bool apply = true)
	: super(type, rowFeSpace, colFeSpace, apply),
	  container(fct)
      { }


      /// Implementation of BoundaryCondition::fillBoundaryCondition().
      virtual void fillBoundaryCondition(DOFVectorBase<double>* vector,
				ElInfo* elInfo,
				const DegreeOfFreedom* dofIndices,
				const BoundaryType* localBound,
				int nBasFcts) override;

    protected:
      std::function<double(WorldVector<double>)> container;
    };
#endif
}

#endif