Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines functions for computing the connectivity of an element
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <cstddef>
      10             : #include <ostream>
      11             : #include <utility>
      12             : #include <vector>
      13             : 
      14             : template <size_t Dim>
      15             : class Index;
      16             : 
      17             : /// Holds functions needed for visualizing data
      18           1 : namespace vis {
      19             : namespace detail {
      20             : /*!
      21             :  * \brief The set of cell topologies used for visualization
      22             :  *
      23             :  * Tensor-product topologies (Line, Quad, Hexahedron) can be generated by
      24             :  * `compute_cells()`. Non-tensor-product topologies (Triangle, Tetrahedron,
      25             :  * Wedge) are necessary for filled cylinders, shells, and balls.
      26             :  *
      27             :  * The numerical values correspond to the XDMF topology types.
      28             :  */
      29             : enum class Topology : int {
      30             :   Line = 2,
      31             :   Triangle = 4,
      32             :   Quad = 5,
      33             :   Tetrahedron = 6,
      34             :   Wedge = 8,
      35             :   Hexahedron = 9
      36             : };
      37             : 
      38             : std::ostream& operator<<(std::ostream& os, const Topology& topology);
      39             : 
      40             : /*!
      41             :  * \brief Represents the number of cells in a particular topology
      42             :  *
      43             :  * Each `CellInTopology` holds an enum of type `Topology` whose
      44             :  * value denotes the type of the topology, e.g. line, quad or hexahedron, and a
      45             :  * vector of bounding indices which are the indices of the grid coordinates in
      46             :  * the contiguous arrays of x, y, and z coordinates that bound the cell.
      47             :  */
      48             : struct CellInTopology {
      49             :   // cppcheck-suppress passedByValue
      50             :   CellInTopology(const Topology& top, std::vector<size_t> bounding_ind)
      51             :       : topology(top), bounding_indices(std::move(bounding_ind)) {}
      52             :   CellInTopology() = default;
      53             :   CellInTopology(const CellInTopology& /*rhs*/) = default;
      54             :   CellInTopology(CellInTopology&& /*rhs*/) = default;
      55             :   CellInTopology& operator=(const CellInTopology& /*rhs*/) = default;
      56             :   CellInTopology& operator=(CellInTopology&& /*rhs*/) = default;
      57             :   ~CellInTopology() = default;
      58             :   Topology topology{Topology::Line};
      59             :   std::vector<size_t> bounding_indices{};
      60             : };
      61             : 
      62             : /// @{
      63             : /*!
      64             :  * \brief Compute the cells in the element.
      65             :  *
      66             :  * Returns a vector of the cells in the topology I1^Dim, i.e. a line if Dim ==
      67             :  * 1, or a hexahedron if Dim == 3. The cells are bounded by lines connecting
      68             :  * grid points along the axes of the element, so if you have (n_x by n_y by n_z)
      69             :  * grid points, you have ((n_x-1) by (n_y-1) by (n_z-1)) cells.
      70             :  *
      71             :  * \note As more topologies are added, e.g. S2, the interface will need slight
      72             :  * modification, however the return type is likely to be able to remain the
      73             :  * same.
      74             :  */
      75             : template <size_t Dim>
      76             : std::vector<CellInTopology> compute_cells(const Index<Dim>& extents);
      77             : 
      78             : std::vector<CellInTopology> compute_cells(const std::vector<size_t>& extents);
      79             : /// @}
      80             : 
      81             : /*!
      82             :  * \brief Return the XDMF 3.0 integer type tag for a given topology.
      83             :  *
      84             :  * The mapping is: Line=2, Triangle=4, Quad=5, Tetrahedron=6, Wedge=8,
      85             :  * Hexahedron=9.
      86             :  * Used when writing mixed-topology connectivity arrays to HDF5 files.
      87             :  */
      88             : int xdmf_topology_type(Topology topology);
      89             : 
      90             : }  // namespace detail
      91             : }  // namespace vis