/export/development/ViennaFEM/viennafem/forwards.h

Go to the documentation of this file.

#ifndef VIENNAFEM_FORWARDS_H
#define VIENNAFEM_FORWARDS_H

/* =========================================================================
   Copyright (c) 2012, Institute for Microelectronics,
                       Institute for Analysis and Scientific Computing,
                       TU Wien.
                             -----------------
               ViennaFEM - The Vienna Finite Element Method Library
                             -----------------

   Author:     Karl Rupp                          rupp@iue.tuwien.ac.at

   License:    MIT (X11), see file LICENSE in the ViennaFEM base directory
============================================================================ */

#include "viennadata/api.hpp"
#include "viennagrid/forwards.h"
#include "viennamath/forwards.h"

namespace viennafem
{
  
  typedef double             numeric_type;

  
  template <long id>
  struct mapping_key_type {}; 

  
  struct none;
  
  
  //
  // Integration
  //
  
  //prototype for Gauss quadrature rules
  template <typename ElementType, unsigned long order, typename InterfaceType = viennamath::default_interface_type>
  struct rt_gauss_quad_element;
  
  //prototype for Strang quadrature rules on triangles
  template <typename ElementType, unsigned long order, typename InterfaceType = viennamath::default_interface_type>
  struct rt_strang_quad_element;

  
  //prototype for Strang quadrature rules on tetrahedra
  template <typename ElementType, unsigned long order, typename InterfaceType = viennamath::default_interface_type>
  struct rt_keast_quad_element;

  
  //
  // Reference elements
  //
  
  struct unit_interval {};

  struct symmetric_interval {};


  
  struct unit_triangle {};
  
  struct symmetric_triangle {};

  
  struct unit_square {};
  
  struct symmetric_square {};
  
  
    
  struct unit_tetrahedron {};
  
  struct symmetric_tetrahedron {};
  
  
  struct unit_cube {};
  
  struct symmetric_cube {};
  
  
  //
  // Basis functions
  //
  
  template <std::size_t order>
  struct lagrange_tag {};
  
  template <typename T>
  struct space_to_id {};
  
  template <std::size_t order>
  struct space_to_id< lagrange_tag<order> >
  {
    enum { value = order };
  };
  
  
  template <typename Cell, typename T>
  struct reference_cell_for_basis {};
  
  template <std::size_t order>
  struct reference_cell_for_basis < viennagrid::line_tag, lagrange_tag<order> >
  {
    typedef unit_interval   type;
  };

  template <std::size_t order>
  struct reference_cell_for_basis < viennagrid::triangle_tag, lagrange_tag<order> >
  {
    typedef unit_triangle   type;
  };

  template <std::size_t order>
  struct reference_cell_for_basis < viennagrid::quadrilateral_tag, lagrange_tag<order> >
  {
    typedef unit_square   type;
  };

  
  template <std::size_t order>
  struct reference_cell_for_basis < viennagrid::tetrahedron_tag, lagrange_tag<order> >
  {
    typedef unit_tetrahedron   type;
  };
  
  template <std::size_t order>
  struct reference_cell_for_basis < viennagrid::hexahedron_tag, lagrange_tag<order> >
  {
    typedef unit_cube   type;
  };
  

  
  // Basis function retrieval:
  template <typename InterfaceType,
            typename BasisTag,
            typename ReferenceCell,
            std::size_t TopologyDim,  //topology dimension of the element for which the basis is to be returned
            std::size_t ElementID>    //element ID (0, ... num-1) of the element at dimension 'topology_dim'
  struct local_basis
  {
    typedef typename BasisTag::ERROR_BASIS_NOT_DEFINED_FOR_THE_PROVIDED_PARAMETER_SET   error_type;
  };                    
  
  
  
  template <unsigned long local_index,
            unsigned long global_index>
  struct dt_dx_key {};
  
  template <unsigned long local_index,
            unsigned long global_index>
  std::ostream & operator<<(std::ostream & stream,
                            dt_dx_key<local_index, global_index> const & dummy)
  {
    stream << "dt_dx_key<" << local_index << "," << global_index << ">";
    return stream;
  }


  struct det_dF_dt_key {};
  
  inline std::ostream & operator<<(std::ostream & stream, det_dF_dt_key const & dummy)
  {
    stream << "det_dF_dt_key";
    return stream;
  }
  
  template <typename CellTag>
  struct dt_dx_handler;
  

  class boundary_key 
  {
    public:
      boundary_key(long id) : id_(id) {}
      
      bool operator<(boundary_key const & other) const { return id_ < other.id_; }
    
    private:
      long id_;
  };

  
  class mapping_key
  {
    public:
      mapping_key(long id) : id_(id) {}
      
      bool operator<(mapping_key const & other) const { return id_ < other.id_; }
    
    private:
      long id_;
  };
  
  namespace detail {}
  
  namespace io {}

} // namespace viennafem




namespace viennadata
{
  namespace config
  {
    template <unsigned long local_index,
              unsigned long global_index>
    struct key_dispatch<viennafem::dt_dx_key<local_index,
                                             global_index>
                       >
    {
      typedef type_key_dispatch_tag    tag;
    };
    
    template <>
    struct key_dispatch<viennafem::det_dF_dt_key>
    {
      typedef type_key_dispatch_tag    tag;
    };
    
    
    
    template <typename ConfigType>
    struct object_identifier<viennagrid::element_t<ConfigType, viennagrid::point_tag> >
    {
      typedef object_provided_id    tag;
      typedef std::size_t           id_type;

      static id_type get(viennagrid::element_t<ConfigType, viennagrid::point_tag> const & obj) { return obj.id(); }
    };

    template <typename ConfigType>
    struct object_identifier<viennagrid::element_t<ConfigType, viennagrid::line_tag> >
    {
      typedef object_provided_id    tag;
      typedef std::size_t           id_type;

      static id_type get(viennagrid::element_t<ConfigType, viennagrid::line_tag> const & obj) { return obj.id(); }
    };
    

    template <typename ConfigType>
    struct object_identifier<viennagrid::element_t<ConfigType, viennagrid::triangle_tag> >
    {
      typedef object_provided_id    tag;
      typedef std::size_t           id_type;

      static id_type get(viennagrid::element_t<ConfigType, viennagrid::triangle_tag> const & obj) { return obj.id(); }
    };
    
    template <typename ConfigType>
    struct object_identifier<viennagrid::element_t<ConfigType, viennagrid::quadrilateral_tag> >
    {
      typedef object_provided_id    tag;
      typedef std::size_t           id_type;

      static id_type get(viennagrid::element_t<ConfigType, viennagrid::quadrilateral_tag> const & obj) { return obj.id(); }
    };
    

    template <typename ConfigType>
    struct object_identifier<viennagrid::element_t<ConfigType, viennagrid::hexahedron_tag> >
    {
      typedef object_provided_id    tag;
      typedef std::size_t           id_type;

      static id_type get(viennagrid::element_t<ConfigType, viennagrid::hexahedron_tag> const & obj) { return obj.id(); }
    };

    template <typename ConfigType>
    struct object_identifier<viennagrid::element_t<ConfigType, viennagrid::tetrahedron_tag> >
    {
      typedef object_provided_id    tag;
      typedef std::size_t           id_type;

      static id_type get(viennagrid::element_t<ConfigType, viennagrid::tetrahedron_tag> const & obj) { return obj.id(); }
    };
    
    
    
    
    template <typename KeyType, typename ValueType, typename ConfigType>
    struct storage<KeyType, ValueType, viennagrid::element_t<ConfigType, viennagrid::point_tag> >
    {
      typedef dense_data_tag    tag;
    };

    template <typename KeyType, typename ValueType, typename ConfigType>
    struct storage<KeyType, ValueType, viennagrid::element_t<ConfigType, viennagrid::line_tag> >
    {
      typedef dense_data_tag    tag;
    };
    
    template <typename KeyType, typename ValueType, typename ConfigType>
    struct storage<KeyType, ValueType, viennagrid::element_t<ConfigType, viennagrid::quadrilateral_tag> >
    {
      typedef dense_data_tag    tag;
    };

    template <typename KeyType, typename ValueType, typename ConfigType>
    struct storage<KeyType, ValueType, viennagrid::element_t<ConfigType, viennagrid::triangle_tag> >
    {
      typedef dense_data_tag    tag;
    };

    template <typename KeyType, typename ValueType, typename ConfigType>
    struct storage<KeyType, ValueType, viennagrid::element_t<ConfigType, viennagrid::hexahedron_tag> >
    {
      typedef dense_data_tag    tag;
    };

    template <typename KeyType, typename ValueType, typename ConfigType>
    struct storage<KeyType, ValueType, viennagrid::element_t<ConfigType, viennagrid::tetrahedron_tag> >
    {
      typedef dense_data_tag    tag;
    };
    
  } //namespace config
} //namespace viennadata


#endif