integral_data.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    integral_data.hh
 * @brief
 * @author  David Flanderka
 */
 
#ifndef INTEGRAL_DATA_HH_
#define INTEGRAL_DATA_HH_
 
#include <vector>
#include <memory>
#include <armadillo>
#include <unordered_set>
#include <unordered_map>
#include <boost/functional/hash.hpp>      // for boost::hash_value
#include "fem/dh_cell_accessor.hh"
#include "tools/revertable_list.hh"
#include "mesh/range_wrapper.hh"
 
template <unsigned int dim> class BulkIntegralAcc;
template <unsigned int dim> class EdgeIntegralAcc;
template <unsigned int dim> class CouplingIntegralAcc;
template <unsigned int dim> class BoundaryIntegralAcc;
template <int spacedim> class ElementAccessor;
 
 
 
/**
 * Helper structure holds data of cell (bulk) integral
 *
 * Data is specified by cell and subset index in EvalPoint object
 */
struct BulkIntegralData {
    /// Default constructor
    BulkIntegralData() {}
 
    /// Constructor with data mebers initialization
    BulkIntegralData(DHCellAccessor dhcell, unsigned int subset_idx)
    : cell(dhcell), subset_index(subset_idx) {}
 
    /// Copy constructor
    BulkIntegralData(const BulkIntegralData &other)
    : cell(other.cell), subset_index(other.subset_index) {}
 
    DHCellAccessor cell;          ///< Specified cell (element)
    unsigned int subset_index;    ///< Index (order) of subset in EvalPoints object
};
 
/**
 * Helper structure holds data of edge integral
 *
 * Data is specified by side and subset index in EvalPoint object
 */
struct EdgeIntegralData {
    /// Default constructor
    EdgeIntegralData()
    : edge_side_range(make_iter<DHEdgeSide, DHCellSide>( DHEdgeSide() ), make_iter<DHEdgeSide, DHCellSide>( DHEdgeSide() )) {}
 
    /// Copy constructor
    EdgeIntegralData(const EdgeIntegralData &other)
    : edge_side_range(other.edge_side_range), subset_index(other.subset_index) {}
 
    /// Constructor with data mebers initialization
    EdgeIntegralData(RangeConvert<DHEdgeSide, DHCellSide> range, unsigned int subset_idx)
    : edge_side_range(range), subset_index(subset_idx) {}
 
    RangeConvert<DHEdgeSide, DHCellSide> edge_side_range;   ///< Specified cell side (element)
    unsigned int subset_index;                              ///< Index (order) of subset in EvalPoints object
};
 
/**
 * Helper structure holds data of neighbour (coupling) integral
 *
 * Data is specified by cell, side and their subset indices in EvalPoint object
 */
struct CouplingIntegralData {
    /// Default constructor
    CouplingIntegralData() {}
 
    /// Constructor with data mebers initialization
    CouplingIntegralData(DHCellAccessor dhcell, unsigned int bulk_idx, DHCellSide dhside, unsigned int side_idx)
    : cell(dhcell), bulk_subset_index(bulk_idx), side(dhside), side_subset_index(side_idx) {}
 
    /// Copy constructor
    CouplingIntegralData(const CouplingIntegralData &other)
    : cell(other.cell), bulk_subset_index(other.bulk_subset_index), side(other.side), side_subset_index(other.side_subset_index) {}
 
    DHCellAccessor cell;
    unsigned int bulk_subset_index;    ///< Index (order) of lower dim subset in EvalPoints object
    DHCellSide side;                   ///< Specified cell side (higher dim element)
    unsigned int side_subset_index;    ///< Index (order) of higher dim subset in EvalPoints object
};
 
/**
 * Helper structure holds data of boundary integral
 *
 * Data is specified by side and subset indices of side and appropriate boundary element in EvalPoint object
 */
struct BoundaryIntegralData {
    /// Default constructor
    BoundaryIntegralData() {}
 
    /// Constructor with data mebers initialization
    BoundaryIntegralData(unsigned int bdr_idx, DHCellSide dhside, unsigned int side_idx)
    : bdr_subset_index(bdr_idx), side(dhside), side_subset_index(side_idx) {}
 
    /// Copy constructor
    BoundaryIntegralData(const BoundaryIntegralData &other)
    : bdr_subset_index(other.bdr_subset_index), side(other.side), side_subset_index(other.side_subset_index) {}
 
    // We don't need hold ElementAccessor of boundary element, side.cond().element_accessor() provides it.
    unsigned int bdr_subset_index;     ///< Index (order) of subset on boundary element in EvalPoints object
    DHCellSide side;                   ///< Specified cell side (bulk element)
    unsigned int side_subset_index;    ///< Index (order) of subset on side of bulk element in EvalPoints object
};
 
 
/**
 * Define vector of RevertableLists.
 *
 * Used in IntegralData structure and in AssemblyBase for sorting integral data of integrals
 * with different quadrature order of same type to separate RevertableLists
 */
template<class Type>
struct RevertableListVector {
public:
    /// Default constructor
    RevertableListVector()
    {}
 
    /// Constructor, initialize vec_list_
    RevertableListVector(uint list_size)
    : vec_list_(size) {}
 
    /// Set size of vec_list_
    void set_size(uint new_size) {
        ASSERT_GE(new_size, vec_list_.size());
        vec_list_.resize(new_size);
    }
 
    /// Finalize temporary part of data.
    inline void make_permanent()
    {
        for (auto &rl : vec_list_) rl.make_permanent();
    }
 
    /// Erase temporary part of data.
    inline void revert_temporary()
    {
        for (auto &rl : vec_list_) rl.revert_temporary();
    }
 
    /// Clear the list.
    inline void reset()
    {
        for (auto &rl : vec_list_) rl.reset();
    }
 
    inline RevertableList<Type> & operator[](std::size_t item) {
        return vec_list_[item];
    }
 
    inline const RevertableList<Type> & operator[](std::size_t item) const {
        return vec_list_[item];
    }
 
private:
    std::vector< RevertableList<Type> > vec_list_;
};
 
 
/// Set of integral data of given dimension used in assemblation
struct IntegralData {
public:
    RevertableListVector<BulkIntegralData>     bulk_;      ///< Holds data for computing bulk integrals.
    RevertableListVector<EdgeIntegralData>     edge_;      ///< Holds data for computing edge integrals.
    RevertableListVector<CouplingIntegralData> coupling_;  ///< Holds data for computing couplings integrals.
    RevertableListVector<BoundaryIntegralData> boundary_;  ///< Holds data for computing boundary integrals.
};
 
 
 
 
 
/// Define Integral Tuple hash function - helper struct of IntegralPtrMap
struct IntegralTplHash {
    std::size_t operator()(std::tuple<uint, uint> tpl) const {
        return boost::hash_value( tpl );
    }
 
    /// Create tuple from dimennsion and size of Quadrature
    static std::tuple<uint, uint> integral_tuple(uint dim, uint quad_size) {
        return std::make_tuple(dim, quad_size);
    }
 
};
 
/// Alias for unordered_map of shared_ptr<Integral> with custom hash
template<typename Integral>
using IntegralPtrMap = std::unordered_map<std::tuple<uint, uint>, std::shared_ptr<Integral>, IntegralTplHash>;
 
 
/// Set of integral of given dimension necessary in assemblation
template<unsigned int dim>
struct DimIntegrals {
    IntegralPtrMap<BulkIntegralAcc<dim>> bulk_;            ///< Bulk integrals of elements
    IntegralPtrMap<EdgeIntegralAcc<dim>> edge_;            ///< Edge integrals between elements of same dimensions
    IntegralPtrMap<CouplingIntegralAcc<dim>> coupling_;    ///< Coupling integrals between elements of dimensions dim and dim-1
    IntegralPtrMap<BoundaryIntegralAcc<dim>> boundary_;    ///< Boundary integrals betwwen side and boundary element of dim-1
};
 
 
 
 
/// Define Integral Tuple hash function - helper struct of OperationMap
struct OperationTplHash {
    std::size_t operator()(std::tuple<std::string, uint> tpl) const {
        return boost::hash_value( tpl );
    }
 
    /// Create tuple from typeid(Operation).name and size of Quadrature
    static std::tuple<std::string, uint> op_tuple(std::string op_type, uint quad_size) {
        return std::make_tuple(op_type, quad_size);
    }
 
};
 
/// Alias for unordered_map of Operation pointer with custom hash
template<typename Operation>
using OperationMap = std::unordered_map<std::tuple<std::string, uint>, Operation *, OperationTplHash>;
 
 
 
#endif /* INTEGRAL_DATA_HH_ */