ExplicitOperators_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_OPERATORS_EXPLICITOPERATORS_FWD_HPP_
#define MEDUSA_BITS_OPERATORS_EXPLICITOPERATORS_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <Eigen/Core>
#include "UniformShapeStorage_fwd.hpp"
#include "RaggedShapeStorage_fwd.hpp"
#include <medusa/bits/types/Vec.hpp>
 
namespace mm {
 
template <class shape_storage_type>
class ExplicitOperators {
  public:
    typedef shape_storage_type shape_storage_t;   
    typedef typename shape_storage_t::vector_t vector_t;  
    typedef typename shape_storage_t::scalar_t scalar_t;  
    enum {  dim = shape_storage_t::dim };
 
  private:
    const shape_storage_t* ss;
 
  public:
    ExplicitOperators() : ss(nullptr) {}
    explicit ExplicitOperators(const shape_storage_t& ss) : ss(&ss) {}
 
    void setShapes(const shape_storage_t& shape_storage_) { ss = &shape_storage_; }
 
    bool hasShapes() const { return ss != nullptr; }
 
    template <typename scalar_field_t>
    typename scalar_type<scalar_field_t>::type lap(const scalar_field_t& u, int node) const {
        return apply<Lap<dim>, scalar_field_t>(u, node);
    }
 
    template <typename scalar_field_t>
    Vec<typename scalar_type<scalar_field_t>::type, ExplicitOperators<shape_storage_type>::dim>
    grad(const scalar_field_t& u, int node) const;
 
    template <typename scalar_field_t>
    typename scalar_type<scalar_field_t>::type neumann(
            const scalar_field_t& u, int node, const vector_t& normal,
            typename scalar_type<scalar_field_t>::type val) const;
 
    template <typename scalar_field_t>
    typename scalar_type<scalar_field_t>::type d1(
            const scalar_field_t& u, int var, int node) const {
        return apply<Der1s<dim>, scalar_field_t>(u, node, Der1<dim>(var));
    }
 
    template <typename scalar_field_t>
    typename scalar_type<scalar_field_t>::type d2(const scalar_field_t& u, int varmin,
                                                  int varmax, int node) const {
        return apply<Der2s<dim>, scalar_field_t>(u, node, Der2<dim>(varmin, varmax));
    }
 
    template <typename op_family_t, typename scalar_field_t>
    typename scalar_type<scalar_field_t>::type apply(
            const scalar_field_t& u, int node, typename op_family_t::operator_t o) const;
 
 
    template <typename op_family_t, typename scalar_field_t>
    typename scalar_type<scalar_field_t>::type apply(const scalar_field_t& u, int node) const {
        return apply<op_family_t, scalar_field_t>(u, node, {});
    }
 
    template <typename S>
    friend std::ostream& operator<<(std::ostream& os, const ExplicitOperators<S>& op);
};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_OPERATORS_EXPLICITOPERATORS_FWD_HPP_