essential_boundary_conditions.h

// This file is part of Hermes3D
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://hpfem.org/.
//
// Hermes3D is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License,
// or (at your option) any later version.
//
// Hermes3D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes3D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

#ifndef __HERMES_COMMON_BOUNDARYCONDITIONS_H
#define __HERMES_COMMON_BOUNDARYCONDITIONS_H

#include "../global.h"
namespace Hermes
{
  namespace Hermes2D
  {
    template<typename Scalar> class ExactSolutionScalar;
    template<typename Scalar> class ExactSolutionVector;
    template<typename Scalar> class EssentialBCs;

    template<typename Scalar>
    class HERMES_API EssentialBoundaryCondition : public Hermes::Mixins::Loggable
    {
    public:
      EssentialBoundaryCondition(Hermes::vector<std::string> markers);
      EssentialBoundaryCondition(std::string marker);

      virtual ~EssentialBoundaryCondition();

      enum EssentialBCValueType {
        BC_FUNCTION,
        BC_CONST
      };

      virtual EssentialBCValueType get_value_type() const = 0;

      virtual Scalar value(double x, double y, double n_x, double n_y, double t_x, double t_y) const = 0;

      void set_current_time(double time);

      double get_current_time() const;

    protected:
      Scalar value_const;

      double current_time;

      Hermes::vector<std::string> markers;

      template<typename T> friend class EssentialBCs;
      template<typename T> friend class Space;
      template<typename T> friend class H1Space;
      template<typename T> friend class L2Space;
      template<typename T> friend class HcurlSpace;
      template<typename T> friend class HdivSpace;
    };

    template<typename Scalar>
    class HERMES_API DefaultEssentialBCConst : public EssentialBoundaryCondition<Scalar> {
    public:
      DefaultEssentialBCConst(Hermes::vector<std::string> markers, Scalar value_const);
      DefaultEssentialBCConst(std::string marker, Scalar value_const);

      Scalar value(double x, double y, double n_x, double n_y, double t_x, double t_y) const;

      inline typename EssentialBoundaryCondition<Scalar>::EssentialBCValueType get_value_type() const { return EssentialBoundaryCondition<Scalar>::BC_CONST; }
    };


    template<typename Scalar>
    class HERMES_API DefaultEssentialBCNonConst : public EssentialBoundaryCondition<Scalar>
    {
    public:
      DefaultEssentialBCNonConst(Hermes::vector<std::string> markers_,
        ExactSolutionScalar<Scalar>* exact_solution);

      DefaultEssentialBCNonConst(std::string marker, ExactSolutionScalar<Scalar>* exact_solution);

      ~DefaultEssentialBCNonConst() {};

      virtual Scalar value(double x, double y, double n_x, double n_y, double t_x, double t_y) const;

      inline typename EssentialBoundaryCondition<Scalar>::EssentialBCValueType get_value_type() const { return EssentialBoundaryCondition<Scalar>::BC_FUNCTION; }

      ExactSolutionScalar<Scalar>* exact_solution;
    };

    template<typename Scalar>
    class HERMES_API DefaultEssentialBCNonConstHcurl : public EssentialBoundaryCondition<Scalar>
    {
    public:
      // Tangential values given by a vector-valued solution.
      DefaultEssentialBCNonConstHcurl(Hermes::vector<std::string> markers_,
        ExactSolutionVector<Scalar>* exact_solution2);
      DefaultEssentialBCNonConstHcurl(std::string marker, ExactSolutionVector<Scalar>* exact_solution2);

      ~DefaultEssentialBCNonConstHcurl() {};

      virtual Scalar value(double x, double y, double n_x, double n_y, double t_x, double t_y) const;

      inline typename EssentialBoundaryCondition<Scalar>::EssentialBCValueType get_value_type() const { return EssentialBoundaryCondition<Scalar>::BC_FUNCTION; }

      ExactSolutionVector<Scalar>* exact_solution2;
    };

    template<typename Scalar>
    class HERMES_API EssentialBCs {
    public:
      EssentialBCs();

      EssentialBCs(Hermes::vector<EssentialBoundaryCondition<Scalar> *> essential_bcs);
      EssentialBCs(EssentialBoundaryCondition<Scalar>* boundary_condition);

      ~EssentialBCs();

      void add_boundary_conditions(Hermes::vector<EssentialBoundaryCondition<Scalar> *> essential_bcs);
      void add_boundary_condition(EssentialBoundaryCondition<Scalar>* essential_bc);

      typename Hermes::vector<EssentialBoundaryCondition<Scalar> *>::const_iterator iterator;
      typename Hermes::vector<EssentialBoundaryCondition<Scalar> *>::const_iterator begin() const;
      typename Hermes::vector<EssentialBoundaryCondition<Scalar> *>::const_iterator end() const;

      EssentialBoundaryCondition<Scalar>* get_boundary_condition(std::string marker);

      void set_current_time(double time);

    private:
      Hermes::vector<EssentialBoundaryCondition<Scalar> *> all;

      Hermes::vector<std::string> markers;
      Hermes::vector<EssentialBoundaryCondition<Scalar> *> BCs;

      EssentialBoundaryCondition<Scalar> * HermesAnyBC;

      void create_marker_cache();

      template<typename T> friend class EssentialBCs;
      template<typename T> friend class Space;
      template<typename T> friend class H1Space;
      template<typename T> friend class L2Space;
      template<typename T> friend class HcurlSpace;
      template<typename T> friend class HdivSpace;
    };
  }
}
#endif