eval_points.hh

Go to the documentation of this file.

/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 *
 * This program 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.
 *
 *
 * @file    eval_points.hh
 * @brief
 * @author  David Flanderka
 */
 
#ifndef EVAL_POINTS_HH_
#define EVAL_POINTS_HH_
 
 
#include <vector>
#include <memory>
#include <armadillo>
#include "mesh/range_wrapper.hh"
#include "system/asserts.hh"
#include "system/armor.hh"
 
class Side;
class Quadrature;
class BulkIntegral;
class EdgeIntegral;
class CouplingIntegral;
class BoundaryIntegral;
template <int spacedim> class ElementAccessor;
 
 
/**
 * @brief Class holds local coordinations of evaluating points (bulk and sides)
 * specified by element dimension.
 */
class EvalPoints : public std::enable_shared_from_this<EvalPoints> {
public:
    /// Undefined dimension of new (empty) object
    static const unsigned int undefined_dim;
 
    /// Maximal number of hold subsets.
    static constexpr unsigned int max_subsets = 10;
 
    /// Maximal average number of points hold in subset.
    static const unsigned int max_subset_points = 30;
 
    /// Constructor
    EvalPoints();
 
    /// Return size of evaluation points object (number of points).
    inline unsigned int size(unsigned int dim) const {
        return dim_eval_points_[dim].size();
    }
 
    /// Return local coordinates of given local point and appropriate dim.
    template<unsigned int dim>
    inline arma::vec::fixed<dim> local_point(unsigned int local_point_idx) const {
        ASSERT_GT(dim, 0).error("Dimension 0 not supported!\n");
        return dim_eval_points_[dim].local_point<dim>(local_point_idx);
    }
 
    /// Return begin index of appropriate subset data.
    inline int subset_begin(unsigned int dim, unsigned int idx) const {
        return dim_eval_points_[dim].subset_begin(idx);
    }
 
    /// Return end index of appropriate subset data.
    inline int subset_end(unsigned int dim, unsigned int idx) const {
        return dim_eval_points_[dim].subset_end(idx);
    }
 
    /// Return number of local points corresponding to subset.
    inline int subset_size(unsigned int dim, unsigned int idx) const {
        return dim_eval_points_[dim].subset_size(idx);
    }
 
    /// Return number of subsets.
    inline unsigned int n_subsets(unsigned int dim) const {
        return dim_eval_points_[dim].n_subsets();
    }
 
    /**
     * Registers point set from quadrature.
     * Returns an object referencing to the EvalPoints and list of its points.
     */
    template <unsigned int dim>
    std::shared_ptr<BulkIntegral> add_bulk(const Quadrature &);
 
    /// The same as add_bulk but for edge points on sides.
    template <unsigned int dim>
    std::shared_ptr<EdgeIntegral> add_edge(const Quadrature &);
 
    /// The same as add_bulk but for points between side points of element of dim and bulk points of element of dim-1.
    template <unsigned int dim>
    std::shared_ptr<CouplingIntegral> add_coupling(const Quadrature &);
 
    /// The same as add_bulk but for edge points on boundary sides.
    template <unsigned int dim>
    std::shared_ptr<BoundaryIntegral> add_boundary(const Quadrature &);
 
    /// Return maximal size of evaluation points objects.
    inline unsigned int max_size() const {
        return max_size_;
    }
 
    inline void clear() {
        for (uint i=0; i<4; ++i)
            dim_eval_points_[i].clear();
    }
 
private:
    /// Subobject holds evaluation points data of one dimension (0,1,2,3)
    class DimEvalPoints {
    public:
        /// Constructor
        DimEvalPoints(unsigned int dim);
 
        /// Return size of evaluation points object (number of points).
        inline unsigned int size() const {
            if (dim_==0) return n_subsets_;
            else return local_points_.size();
        }
 
        /// Return local coordinates of given local point.
        template<unsigned int dim>
        inline arma::vec::fixed<dim> local_point(unsigned int local_point_idx) const {
            ASSERT_LT(local_point_idx, this->size());
            return local_points_.vec<dim>(local_point_idx);
        }
 
        /// Return begin index of appropriate subset data.
        inline int subset_begin(unsigned int idx) const {
            ASSERT_LT(idx, n_subsets());
            return subset_starts_[idx];
        }
 
        /// Return end index of appropriate subset data.
        inline int subset_end(unsigned int idx) const {
            ASSERT_LT(idx, n_subsets());
            return subset_starts_[idx+1];
        }
 
        /// Return number of local points corresponding to subset.
        inline int subset_size(unsigned int idx) const {
            ASSERT_LT(idx, n_subsets());
            return subset_starts_[idx+1] - subset_starts_[idx];
        }
 
        /// Return number of subsets.
        inline unsigned int n_subsets() const {
            return n_subsets_;
        }
 
        /// Adds set of local point to local_points_ (bulk or side).
        template <unsigned int dim>
        void add_local_points(const Armor::Array<double> & quad_points);
 
        /// Adds new subset and its end size to subset_starts_ array.
        uint add_subset();
 
        inline void clear() {
            local_points_.resize(0);
            n_subsets_ = 0;
        }
    private:
        Armor::Array<double> local_points_;                           ///< Local coords of points vector
        std::array<int, EvalPoints::max_subsets+1> subset_starts_;    ///< Indices of subsets data in local_points_ vector, used size is n_subsets_ + 1
        unsigned int n_subsets_;                                      ///< Number of subset
        unsigned int dim_;                                            ///< Dimension of local points
    };
 
    inline void set_max_size() {
        max_size_ = std::max( std::max( size(0), size(1) ), std::max( size(2), size(3) ) );
    }
 
 
    /// Sub objects of dimensions 0,1,2,3
    std::array<DimEvalPoints, 4> dim_eval_points_;
 
    /// BulkIntegral objects of dimension 0,1,2,3
    std::array< std::shared_ptr<BulkIntegral>, 4> bulk_integrals_;
 
    /// EdgeIntegral objects of dimension 1,2,3
    std::array< std::shared_ptr<EdgeIntegral>, 3> edge_integrals_;
 
    /// Maximal number of used EvalPoints.
    unsigned int max_size_;
 
};
 
 
#endif /* EVAL_POINTS_HH_ */