dh_cell_accessor.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    dh_cell_accessor.hh
 * @brief
 * @author  David Flanderka
 */

#ifndef DH_CELL_ACCESSOR_HH_
#define DH_CELL_ACCESSOR_HH_

#include "mesh/accessors.hh"
#include "mesh/sides.h"
#include "mesh/neighbours.h"
#include "fem/dofhandler.hh"

class DHCellSide;
class DHNeighbSide;
class DHEdgeSide;

/**
 * @brief Cell accessor allow iterate over DOF handler cells.
 *
 * Iterating is possible over different ranges of local and ghost elements.
 *
 * Iterator is defined by:
 *  - DOF handler
 *  - local index of DOF cell (iterated value)
 */
class DHCellAccessor {
public:
    /// Default invalid accessor.
    DHCellAccessor()
    : dof_handler_(NULL)
    {}

    /**
     * DOF cell accessor.
     */
    DHCellAccessor(const DOFHandlerMultiDim *dof_handler, unsigned int loc_idx)
    : dof_handler_(dof_handler), loc_ele_idx_(loc_idx)
    {}

    /// Return local index to element (index of DOF handler).
    inline unsigned int local_idx() const {
        ASSERT_LT_DBG(loc_ele_idx_, dof_handler_->el_ds_->lsize()+dof_handler_->ghost_4_loc.size()).error("Local element index is out of range!\n");
        return loc_ele_idx_;
    }

    /// Return serial idx to element of loc_ele_idx_.
    inline unsigned int elm_idx() const {
        unsigned int ds_lsize = dof_handler_->el_ds_->lsize();
        if (local_idx()<ds_lsize) return dof_handler_->mesh()->get_el_4_loc()[loc_ele_idx_]; //own elements
        else return dof_handler_->ghost_4_loc[loc_ele_idx_-ds_lsize]; //ghost elements
    }

    /// Return ElementAccessor to element of loc_ele_idx_.
    inline const ElementAccessor<3> elm() const {
        return dof_handler_->mesh()->element_accessor( elm_idx() );
    }

    /**
     * @brief Fill vector of the global indices of dofs associated to the cell.
     *
     * @param indices Vector of dof indices on the cell.
     */
    unsigned int get_dof_indices(std::vector<int> &indices) const;

    /**
     * @brief Returns the indices of dofs associated to the cell on the local process.
     *
     * @param indices Array of dof indices on the cell.
     */
    unsigned int get_loc_dof_indices(std::vector<LongIdx> &indices) const;

    /// Return number of dofs on given cell.
    unsigned int n_dofs() const;

    /**
     * @brief Return dof on a given cell.
     * @param idof Number of dof on the cell.
     */
    const Dof &cell_dof(unsigned int idof) const;

    /// Return dimension of element appropriate to cell.
    inline unsigned int dim() const {
        return elm().dim();
    }

    /**
     * @brief Returns finite element object for given space dimension.
     */
    template<unsigned int dim>
    FiniteElement<dim> *fe() const {
        ElementAccessor<3> elm_acc = this->elm();
        return dof_handler_->ds_->fe<dim>(elm_acc);
    }

    /// Check validity of accessor (see default constructor)
    inline bool is_valid() const {
        return dof_handler_ != NULL;
    }

    /// Returns range of cell sides
    Range<DHCellSide> side_range() const;

    /// Returns range of neighbour cell of lower dimension corresponding to cell of higher dimension
    RangeConvert<DHNeighbSide, DHCellSide> neighb_sides() const;

    /// Return true if accessor represents own element (false for ghost element)
    inline bool is_own() const {
        return (loc_ele_idx_ < dof_handler_->el_ds_->lsize());
    }

    /// Iterates to next local element.
    inline void inc() {
        loc_ele_idx_++;
    }

    /// Comparison of accessors.
    bool operator==(const DHCellAccessor& other) {
        return (loc_ele_idx_ == other.loc_ele_idx_);
    }

private:
    /// Pointer to the DOF handler owning the element.
    const DOFHandlerMultiDim * dof_handler_;
    /// Index into DOFHandler::el_4_loc array.
    unsigned int loc_ele_idx_;

    friend class DHCellSide;
    friend class DHEdgeSide;
    friend class DHNeighbSide;
};


/**
 * @brief Side accessor allows to iterate over sides of DOF handler cell.
 *
 * Iterator is defined by:
 *  - DOF handler cell
 *  - index of Side in DOF cell (iterated value)
 */
class DHCellSide {
public:

    /**
     * @brief Default invalid accessor.
     *
     * Create invalid \p dh_cell_accessor_.
     */
    DHCellSide() {}

    /**
     * DOF cell side accessor.
     */
    DHCellSide(const DHCellAccessor &dh_cell_accessor, unsigned int side_idx)
    : dh_cell_accessor_(dh_cell_accessor), side_idx_(side_idx) {}

    /// Check validity of accessor (see default constructor)
    inline virtual bool is_valid() const {
        return dh_cell_accessor_.is_valid();
    }

    /// Return Side of given cell and side_idx.
    inline const Side * side() const {
        ASSERT( this->is_valid() );
        return new Side( const_cast<const Mesh*>(dh_cell_accessor_.dof_handler_->mesh()), dh_cell_accessor_.elm_idx(), side_idx_ );
    }

    /// Return DHCellAccessor appropriate to the side.
    inline const DHCellAccessor cell() const {
        return dh_cell_accessor_;
    }

    /// Return dimension of element appropriate to the side.
    inline unsigned int dim() const {
        return cell().dim();
    }

    /// Returns range of all sides looped over common Edge.
    RangeConvert<DHEdgeSide, DHCellSide> edge_sides() const;

    /**
     * Returns total number of sides appropriate to Edge that owns actual cell side.
     *
     * return empty range if no element connected to Edge is local
     */
    unsigned int n_edge_sides() const;

    /// Iterates to next local element.
    inline virtual void inc() {
        side_idx_++;
    }

    /// Comparison of accessors.
    bool operator==(const DHCellSide& other) {
        return (side_idx_ == other.side_idx_);
    }

private:
    /// Appropriate DHCellAccessor.
    DHCellAccessor dh_cell_accessor_;
    /// Index of side.
    unsigned int side_idx_;

    friend class DHEdgeSide;
};


/**
 * @brief Class allows to iterate over sides of edge.
 *
 * Iterator is defined by:
 *  - DOF handler
 *  - global index of Edge (constant value)
 *  - index of Side in Edge (iterated value)
 *
 * Note: Class is used only internally. Appropriate range method (DHCellSide::edge_sides) uses convertible iterators
 * and returns corresponding DHCellSide.
 */
class DHEdgeSide {
public:
    /// Default invalid accessor.
    DHEdgeSide() : dof_handler_(nullptr), edge_idx_(0) {}

    /**
     * Valid accessor allows iterate over sides.
     */
    DHEdgeSide(const DHCellSide &cell_side, unsigned int side_idx)
    : dof_handler_(cell_side.dh_cell_accessor_.dof_handler_),
      edge_idx_(cell_side.dh_cell_accessor_.elm()->edge_idx(cell_side.side_idx_)),
      side_idx_(side_idx)
    {}

    /// Check validity of accessor (see default constructor)
    inline bool is_valid() const {
        return (dof_handler_!=nullptr);
    }

    /// Iterates to next edge side.
    inline void inc() {
        side_idx_++;
    }

    /// Comparison of accessors.
    bool operator==(const DHEdgeSide& other) {
        return (edge_idx_ == other.edge_idx_) && (side_idx_ == other.side_idx_);
    }

    /// This class is implicitly convertible to DHCellSide.
    operator DHCellSide() const {
        SideIter side = dof_handler_->mesh()->edges[edge_idx_].side(side_idx_);
        DHCellAccessor cell = dof_handler_->cell_accessor_from_element( side->elem_idx() );
        return DHCellSide(cell, side->side_idx());
    }

private:
    /// Pointer to the DOF handler owning the element.
    const DOFHandlerMultiDim * dof_handler_;
    /// Global index of Edge.
    unsigned int edge_idx_;
    /// Index of side owned by Edge.
    unsigned int side_idx_;
};


/**
 * @brief Class allows to iterate over sides of neighbour.
 *
 * Class returns only local cells (owns + ghosts), non-local cells are skipped.
 *
 * Iterator is defined by:
 *  - DOF handler cell accessor
 *  - index of Neighbour on cell (iterated value)
 *  - maximal index of Neighbour (allow to skip non-local cells)
 *
 * Note: Class is used only internally. Appropriate range method (DHCellAccessor::neighb_sides) uses convertible
 * iterators and returns corresponding DHCellSide.
 */
class DHNeighbSide {
public:
    /// Default invalid accessor.
    DHNeighbSide() {}

    /**
     * @brief Valid accessor allows iterate over neighbor sides.
     *
     * @param dh_cell    Element of lower dim.
     * @param neighb_idx Index of neighbour.
     * @param max_idx    Maximal index of neighbour, method inc() doesn't set neighb_idx_ on higher value.
     */
    DHNeighbSide(const DHCellAccessor &dh_cell, unsigned int neighb_idx, unsigned int max_idx)
    : dh_cell_(dh_cell), neighb_idx_(neighb_idx), max_idx_(max_idx)
    {
        // Skip non-local cells
        while ( (neighb_idx_<max_idx_) && not_local_cell() ) {
            neighb_idx_++;
        }
    }

    /// Check validity of accessor (see default constructor of DHCellAccessor)
    inline bool is_valid() const {
        return dh_cell_.is_valid();
    }

    /// Iterates to next neighbour side.
    inline void inc() {
        // Skip non-local cells
        do {
            neighb_idx_++;
            if (neighb_idx_>=max_idx_) break; //stop condition at the end item of range
        } while ( not_local_cell() );
    }

    /// Comparison of accessors.
    bool operator==(const DHNeighbSide& other) {
        return (neighb_idx_ == other.neighb_idx_);
    }

    /// This class is implicitly convertible to DHCellSide.
    operator DHCellSide() const {
        SideIter side = dh_cell_.elm()->neigh_vb[neighb_idx_]->side();
        DHCellAccessor cell = dh_cell_.dof_handler_->cell_accessor_from_element( side->elem_idx() );
        return DHCellSide(cell, side->side_idx());
    }

private:
    /// Check if cell side of neighbour is not local (allow skip invalid accessors).
    inline bool not_local_cell() {
        return ( dh_cell_.dof_handler_->global_to_local_el_idx_.end() ==
            dh_cell_.dof_handler_->global_to_local_el_idx_.find((LongIdx)dh_cell_.elm()->neigh_vb[neighb_idx_]->side()->elem_idx()) );
    }

    /// Appropriate cell accessor.
    DHCellAccessor dh_cell_;
    /// Index into neigh_vb array
    unsigned int neighb_idx_;
    /// Maximal index into neigh_vb array
    unsigned int max_idx_;
};


/*************************************************************************************
 * Implementation of inlined methods.
 */

inline unsigned int DHCellAccessor::get_dof_indices(std::vector<int> &indices) const
{
  ASSERT_LT( loc_ele_idx_+1, dof_handler_->cell_starts.size() )(loc_ele_idx_)(dof_handler_->cell_starts.size());
  unsigned int ndofs = 0;
  ndofs = dof_handler_->cell_starts[loc_ele_idx_+1]-dof_handler_->cell_starts[loc_ele_idx_];
  for (unsigned int k=0; k<ndofs; k++)
    indices[k] = dof_handler_->dof_indices[dof_handler_->cell_starts[loc_ele_idx_]+k];

  return ndofs;
}


inline unsigned int DHCellAccessor::get_loc_dof_indices(std::vector<LongIdx> &indices) const
{
  unsigned int ndofs = 0;
  ndofs = dof_handler_->cell_starts[loc_ele_idx_+1]-dof_handler_->cell_starts[loc_ele_idx_];
  for (unsigned int k=0; k<ndofs; k++)
    indices[k] = dof_handler_->cell_starts[loc_ele_idx_]+k;

  return ndofs;
}


inline unsigned int DHCellAccessor::n_dofs() const
{
    switch (this->dim()) {
        case 1:
            return fe<1>()->n_dofs();
            break;
        case 2:
            return fe<2>()->n_dofs();
            break;
        case 3:
            return fe<3>()->n_dofs();
            break;
    }
    return 0; // only fix compiler warning
}


inline const Dof &DHCellAccessor::cell_dof(unsigned int idof) const
{
    switch (this->dim())
    {
        case 1:
            return fe<1>()->dof(idof);
            break;
        case 2:
            return fe<2>()->dof(idof);
            break;
        case 3:
            return fe<3>()->dof(idof);
            break;
    }
}


inline Range<DHCellSide> DHCellAccessor::side_range() const {
    auto bgn_it = make_iter<DHCellSide>( DHCellSide(*this, 0) );
    auto end_it = make_iter<DHCellSide>( DHCellSide(*this, dim()+1) );
    return Range<DHCellSide>(bgn_it, end_it);
}


inline RangeConvert<DHNeighbSide, DHCellSide> DHCellAccessor::neighb_sides() const {
    unsigned int upper_bound = this->elm()->n_neighs_vb();
    auto bgn_it = make_iter<DHNeighbSide, DHCellSide>( DHNeighbSide(*this, 0, upper_bound) );
    auto end_it = make_iter<DHNeighbSide, DHCellSide>( DHNeighbSide(*this, upper_bound, upper_bound) );
    return RangeConvert<DHNeighbSide, DHCellSide>(bgn_it, end_it);
}


inline RangeConvert<DHEdgeSide, DHCellSide> DHCellSide::edge_sides() const {
    return RangeConvert<DHEdgeSide, DHCellSide>(make_iter<DHEdgeSide, DHCellSide>( DHEdgeSide( *this, 0) ),
                                                make_iter<DHEdgeSide, DHCellSide>( DHEdgeSide( *this, n_edge_sides()) ));
}


inline unsigned int DHCellSide::n_edge_sides() const {
    unsigned int edge_idx = dh_cell_accessor_.elm()->edge_idx(side_idx_);
    Edge *edg = &dh_cell_accessor_.dof_handler_->mesh()->edges[edge_idx];
    for (int sid=0; sid<edg->n_sides; sid++)
        if ( dh_cell_accessor_.dof_handler_->el_is_local(edg->side(sid)->element().idx()) ) return edg->n_sides;
    return 0;
}



#endif /* DH_CELL_ACCESSOR_HH_ */