Line data    Source code

       1             : // This file is part of the Mamico project. For conditions of distribution
       2             : // and use, please see the copyright notice in Mamico's main folder
       3             : #pragma once
       4             : 
       5             : #include "coupling/CouplingMDDefinitions.h"
       6             : #include "coupling/datastructures/CouplingCell.h"
       7             : #include "coupling/indexing/IndexingService.h"
       8             : 
       9             : namespace coupling {
      10             : namespace datastructures {
      11             : template <class CellIndexT, unsigned int dim> class CellContainer;
      12             : } // namespace datastructures
      13             : } // namespace coupling
      14             : 
      15             : /**
      16             :  * @brief provides access to the coupling cells. Base class for the class coupling::datastructures::LinkedCellContainer
      17             :  *
      18             :  * The CellContainer is intended to be used for a fixed indexing domain. Once created, it is assumed to hold all cells in that domain. For example, a
      19             :  * CellContainer created with template parameter I02 is expected to contain all cells that are accessible by iterating through I02. CellContainers do not
      20             :  * capture relevant cells automatically. It is the responsibility of the calling function to allocate the cells and populate the container completely before
      21             :  * using it. Due to this complete and contiguous nature of the datastructure, direct indexing is allowed, and the cell container is expected to start at
      22             :  * location 0 of the indexing domain it was initialized with. CellContainers contain pointers to coupling cells, the cells are not owned by the container, hence
      23             :  * the calling function must delete the cells later.
      24             :  * @tparam dim Number of dimensions; it can be 1, 2 or 3
      25             :  */
      26          56 : template <class CellIndexT, unsigned int dim> class coupling::datastructures::CellContainer {
      27             : 
      28             : public:
      29          32 :   CellContainer() { _couplingCells.reserve(CellIndexT::linearNumberCellsInDomain); }
      30          36 :   CellContainer(std::vector<coupling::datastructures::CouplingCell<dim>*> couplingCells) {
      31          36 :     _couplingCells.reserve(CellIndexT::linearNumberCellsInDomain);
      32       33476 :     for (auto cell : couplingCells) {
      33       33440 :       *this << cell;
      34             :     }
      35          36 :   }
      36             : 
      37             :   /** Index based access, returns a pointer to the coupling cell
      38             :    * @param index index An index of type CellIndexT i.e. from the initializing subdomain
      39             :    * @return the pointer to the requested cell
      40             :    */
      41        4000 :   coupling::datastructures::CouplingCell<dim>* operator[](CellIndexT index) const {
      42             : #if (COUPLING_MD_ERROR == COUPLING_MD_YES)
      43        4000 :     if (_couplingCells.size() < CellIndexT::linearNumberCellsInDomain) {
      44           0 :       std::cout << "CellContainer<" << CellIndexT::TNAME << "," << dim << "> accessed but not full " << std::endl;
      45           0 :       std::exit(EXIT_FAILURE);
      46             :     }
      47             : #endif
      48        4000 :     return _couplingCells[indexing::convertToScalar(index)];
      49             :   }
      50             : 
      51             :   /** Adds a new coupling cell to the datastructure at the next index (will only work if the data structure is not yet full)
      52             :    * @param cell a pointer to the cell to be inserted
      53             :    */
      54       41440 :   void operator<<(coupling::datastructures::CouplingCell<dim>* couplingCell) {
      55             : #if (COUPLING_MD_ERROR == COUPLING_MD_YES)
      56       41440 :     if (_couplingCells.size() >= CellIndexT::linearNumberCellsInDomain) {
      57           0 :       std::cout << "CellContainer<" << CellIndexT::TNAME << "," << dim << "> can only hold " << CellIndexT::linearNumberCellsInDomain << " coupling cells!"
      58           0 :                 << std::endl;
      59           0 :       std::exit(EXIT_FAILURE);
      60             :     }
      61             : #endif
      62       41440 :     _couplingCells.push_back(couplingCell);
      63       41440 :   }
      64             : 
      65             :   /**
      66             :    * Returns size of the underlying container.
      67             :    *
      68             :    * This size is notably not the number of cells in the index domain. However, in practice the two numbers should be identical, as accessing contents of an
      69             :    * incomplete cotnainer is not allowed.
      70             :    * @return the number of cells stored currently
      71             :    */
      72           4 :   unsigned int size() const { return _couplingCells.size(); }
      73             : 
      74             :   /**
      75             :    * @brief Provides iterator functionality (increment, access as <*cell, index> pair, equality)
      76             :    */
      77       56000 :   class Iterator {
      78             :   public:
      79             :     using CouplingCellIterator = typename std::vector<coupling::datastructures::CouplingCell<dim>*>::const_iterator;
      80             : 
      81        8064 :     Iterator(CouplingCellIterator itCouplingCells, typename CellIndexT::IndexIterator itIdx) : _itCouplingCells(itCouplingCells), _itIdx(itIdx) {}
      82             : 
      83             :     /**
      84             :      * Iterator access, returning the data at the current iterator location
      85             :      *
      86             :      * @return a std::pair with the cell pointer and the index of the data that the iterator points to
      87             :      */
      88       38896 :     const std::pair<coupling::datastructures::CouplingCell<dim>*, CellIndexT> operator*() const { return std::make_pair(*_itCouplingCells, *_itIdx); }
      89             : 
      90       37440 :     Iterator& operator++() {
      91        9440 :       ++_itCouplingCells;
      92       37440 :       ++_itIdx;
      93        9440 :       return *this;
      94             :     }
      95             : 
      96       28000 :     Iterator operator++(int) {
      97       28000 :       Iterator tmp = *this;
      98       28000 :       ++(*this);
      99       28000 :       return tmp;
     100             :     }
     101             : 
     102        4000 :     friend bool operator==(const Iterator& a, const Iterator& b) { return a._itCouplingCells == b._itCouplingCells; }
     103             : 
     104       17456 :     friend bool operator!=(const Iterator& a, const Iterator& b) { return !(a == b); }
     105             : 
     106             :   private:
     107             :     /**Iterator to underlying cell* vector */
     108             :     CouplingCellIterator _itCouplingCells;
     109             : 
     110             :     /**Iterator over the index subdomain
     111             :      *
     112             :      * As the container spans the whole index subdomain, the iterators already available for this index domain can be reused, and incremented in lockstep with
     113             :      * the internal iterator for the vector
     114             :      */
     115             :     typename CellIndexT::IndexIterator _itIdx;
     116             :   };
     117             : 
     118             :   /** Provides pointer to beginning of iterator of this container */
     119          48 :   Iterator begin() const { return Iterator(_couplingCells.begin(), CellIndexT::begin()); }
     120             : 
     121             :   /** Provides pointer to end of iterator of this container */
     122        8016 :   Iterator end() const { return Iterator(_couplingCells.end(), CellIndexT::end()); }
     123             : 
     124             : protected:
     125             :   /**
     126             :    * Holds pointers to all coupling cells.
     127             :    * This is used for interfacing to send-recv
     128             :    * operations.
     129             :    */
     130             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _couplingCells;
     131             : };