BaseRectangularQuad.h

#pragma once
 
#include <Caribou/config.h>
#include <Caribou/constants.h>
#include <Caribou/Geometry/Element.h>
#include <Eigen/Core>
 
 
namespace caribou::geometry {
 
template<typename Derived>
struct BaseRectangularQuad : public Element<Derived> {
    // Types
    using Base = Element<Derived>;
 
    using LocalCoordinates = typename Base::LocalCoordinates;
    using WorldCoordinates = typename Base::WorldCoordinates;
 
    using GaussNode = typename Base::GaussNode;
 
    template <UNSIGNED_INTEGER_TYPE Dim>
    using Vector = typename Base::template Vector<Dim>;
 
    template <UNSIGNED_INTEGER_TYPE Rows, UNSIGNED_INTEGER_TYPE Cols>
    using Matrix = typename Base::template Matrix<Rows, Cols>;
 
    // Constants
    static constexpr auto CanonicalDimension = Base::CanonicalDimension;
    static constexpr auto Dimension = Base::Dimension;
    static constexpr auto NumberOfNodesAtCompileTime = Base::NumberOfNodesAtCompileTime;
    static constexpr auto NumberOfGaussNodesAtCompileTime = Base::NumberOfGaussNodesAtCompileTime;
 
    static_assert(Dimension == 2 or Dimension == 3, "Quads can only be of dimension 2 or 3.");
 
    using Size = Vector<CanonicalDimension>;
    using Rotation = Matrix<Dimension,Dimension>;
 
    BaseRectangularQuad() : p_center(WorldCoordinates::Constant(0)), p_H(Size::Constant(2)), p_R(Rotation::Identity()) {}
 
    explicit BaseRectangularQuad(WorldCoordinates center) : p_center(center), p_H(Size::Constant(2)), p_R(Rotation::Identity()) {}
 
    BaseRectangularQuad(WorldCoordinates center, Size H) : p_center(center), p_H(H), p_R(Rotation::Identity()) {}
 
    BaseRectangularQuad(WorldCoordinates center, Rotation R) : p_center(center), p_H(Size::Constant(2)), p_R(R) {}
 
    BaseRectangularQuad(WorldCoordinates center, Size H, Rotation R) : p_center(center), p_H(H), p_R(R) {}
 
    // Public methods common to all rectangular quad types
 
    inline auto edges() const {
        return self().boundary_elements_node_indices();
    }
 
    inline auto rotation() const -> const Rotation  & {
        return p_R;
    };
 
    inline auto size() const -> const Size  & {
        return p_H;
    };
 
    inline auto T(const LocalCoordinates & coordinates) const -> WorldCoordinates {
        if constexpr (Dimension == 2) {
            return p_center + p_R * (coordinates.cwiseProduct(p_H / 2.));
        } else {
            WorldCoordinates p;
            p.template block<CanonicalDimension, 1>(0,0) = coordinates.cwiseProduct(p_H / 2.);
            p[2] = 0.;
            return p_center + p_R * p;
        }
    }
 
private:
    // Implementations
    friend struct Element<Derived>;
    [[nodiscard]]
    inline auto get_number_of_nodes() const {return NumberOfNodesAtCompileTime;}
    [[nodiscard]]
    inline auto get_number_of_gauss_nodes() const {return NumberOfGaussNodesAtCompileTime;}
    inline auto get_center() const {return p_center;};
    [[nodiscard]]
    inline auto get_number_of_boundary_elements() const -> UNSIGNED_INTEGER_TYPE {return 4;};
 
    auto self() -> Derived& { return *static_cast<Derived*>(this); }
    auto self() const -> const Derived& { return *static_cast<const Derived*>(this); }
protected:
    WorldCoordinates p_center; 
    Size p_H; 
    Rotation p_R; 
};
}