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://www.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;

    enum EssentialBCValueType
    {
      BC_FUNCTION,
      BC_CONST
    };

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

      virtual ~EssentialBoundaryCondition();

      virtual EssentialBCValueType get_value_type() const = 0;

      virtual Scalar value(double x, double y) const = 0;

      void set_current_time(double time);

      double get_current_time() const;

    protected:
      Scalar value_const;

      double current_time;

      std::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(std::vector<std::string> markers, Scalar value_const);
      DefaultEssentialBCConst(std::string marker, Scalar value_const);

      Scalar value(double x, double y) const;

      inline EssentialBCValueType get_value_type() const { return BC_CONST; }
    };

    // Constructor with multiple markers, setting velocity at inlet(vel_inlet), domain height(H) and startup time(startup_time) - all parameters are of this example - DERIVED - class.
    // Members of MyEssentialBCNonConst.

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

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

      ~DefaultEssentialBCNonConst() {};

      virtual Scalar value(double x, double y) const;

      inline EssentialBCValueType get_value_type() const { return BC_FUNCTION; }

      ExactSolutionScalar<Scalar>* exact_solution;
    };

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

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

      ~EssentialBCs();

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

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

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

      const std::vector<std::string>& get_markers() const;

      void set_current_time(double time);

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

      std::vector<std::string> markers;
      std::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