Coarse_Cell.h

Go to the documentation of this file.

#ifndef COMMA_PROJECT_COARSE_CELL_H
#define COMMA_PROJECT_COARSE_CELL_H
 
/*
 * CoMMA
 *
 * Copyright © 2024 ONERA
 *
 * Authors: Nicolas Lantos, Alberto Remigi, and Riccardo Milani
 * Contributors: Karim Anemiche
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#include <memory>
#include <optional>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "CoMMA/Dual_Graph.h"
 
namespace comma {
 
template<
  typename CoMMAIndexType,
  typename CoMMAWeightType,
  typename CoMMAIntType>
class Coarse_Cell {
public:
  using DualGraphPtr =
    std::shared_ptr<Dual_Graph<CoMMAIndexType, CoMMAWeightType, CoMMAIntType>>;
 
  Coarse_Cell(
    DualGraphPtr fc_graph,
    CoMMAIndexType i_cc,
    const std::unordered_set<CoMMAIndexType> &s_fc,
    CoMMAIntType compactness,
    bool is_isotropic = true
  ) :
    _idx(i_cc),
    _fc_graph(fc_graph),
    _compactness(compactness),
    _cardinality(static_cast<CoMMAIntType>(s_fc.size())),
    _is_isotropic(is_isotropic),
    _s_fc(s_fc) {}
 
  virtual ~Coarse_Cell() = default;
 
  CoMMAIndexType _idx;
 
  DualGraphPtr _fc_graph;
 
  CoMMAIntType _compactness;
 
  CoMMAIntType _cardinality;
 
  bool _is_isotropic;
 
  std::unordered_set<CoMMAIndexType> _s_fc;
 
  inline bool is_connected() { return _compactness > 0; }
 
  virtual void insert_cell(
    const CoMMAIndexType i_fc, const std::optional<CoMMAIntType> new_compactness
  ) {
    _s_fc.insert(i_fc);
    ++_cardinality;
    _compactness = new_compactness.has_value()
      ? new_compactness.value()
      : _fc_graph->compute_min_fc_compactness_inside_a_cc(_s_fc);
  }
 
  virtual void insert_cells(
    const std::unordered_set<CoMMAIndexType> &fcs,
    const std::optional<CoMMAIntType> new_compactness
  ) {
    _s_fc.insert(fcs.begin(), fcs.end());
    _cardinality += fcs.size();
    _compactness = new_compactness.has_value()
      ? new_compactness.value()
      : _fc_graph->compute_min_fc_compactness_inside_a_cc(_s_fc);
  }
};
 
template<
  typename CoMMAIndexType,
  typename CoMMAWeightType,
  typename CoMMAIntType>
class Coarse_Cell_Subgraph :
  Coarse_Cell<CoMMAIndexType, CoMMAWeightType, CoMMAIntType> {
public:
  using BaseClass = Coarse_Cell<CoMMAIndexType, CoMMAWeightType, CoMMAIntType>;
 
  using typename BaseClass::DualGraphPtr;
 
  using SubGraphType = Subgraph<CoMMAIndexType, CoMMAWeightType, CoMMAIntType>;
 
  using SubGraphPtr = std::shared_ptr<SubGraphType>;
 
  Coarse_Cell_Subgraph(
    DualGraphPtr fc_graph,
    CoMMAIndexType i_cc,
    const std::unordered_set<CoMMAIndexType> &s_fc,
    CoMMAIntType compactness,
    bool is_isotropic = true
  ) :
    BaseClass(fc_graph, i_cc, s_fc, compactness, is_isotropic),
    _is_connected(compactness > 0),
    _is_connectivity_up_to_date(true) {
    // initialization vectors
    CoMMAIndexType position = 0;
    std::vector<CoMMAWeightType> volumes;
    std::vector<CoMMAWeightType> CSR_vals{};
    std::vector<CoMMAIndexType> CSR_row = {0};
    std::vector<CoMMAIndexType> CSR_col{};
    std::vector<CoMMAIndexType> col_ind{};
    std::vector<CoMMAIndexType> mapping{};
    for (const CoMMAIndexType &i_fc : this->_s_fc) {
      // we add to the mapping the i_fc
      mapping.push_back(i_fc);
      auto n_it = this->_fc_graph->neighbours_cbegin(i_fc);
      auto w_it = this->_fc_graph->weights_cbegin(i_fc);
      for (; n_it != this->_fc_graph->neighbours_cend(i_fc)
           && w_it != this->_fc_graph->weights_cend(i_fc);
           ++n_it, ++w_it) {
        if (std::find(this->_s_fc.begin(), this->_s_fc.end(), *n_it)
            != this->_s_fc.end()) {
          ++position;
          col_ind.push_back(*n_it);
          CSR_vals.push_back(*w_it);
        }
      }
      CSR_row.push_back(position);
      volumes.push_back(this->_fc_graph->_volumes[i_fc]);
    }
 
    // Map in the local subgraph
    for (auto it = col_ind.begin(); it != col_ind.end(); ++it) {
      auto indx = std::find(mapping.begin(), mapping.end(), *it);
      CSR_col.push_back(indx - mapping.begin());
    }
 
    _cc_graph = std::make_shared<SubGraphType>(
      s_fc.size(), CSR_row, CSR_col, CSR_vals, volumes, mapping, is_isotropic
    );
  }
 
  void insert_cell(
    const CoMMAIndexType i_fc, const std::optional<CoMMAIntType> new_compactness
  ) override {
    // As base class...
    this->_s_fc.insert(i_fc);
    ++this->_cardinality;
    this->_compactness = new_compactness.has_value()
      ? new_compactness.value()
      : this->_fc_graph->compute_min_fc_compactness_inside_a_cc(this->_s_fc);
    // ...but now add to the subgraph
    _cc_graph->insert_node(
      this->_fc_graph->get_neighbours(i_fc),
      i_fc,
      this->_fc_graph->_volumes[i_fc],
      this->_fc_graph->get_weights(i_fc)
    );
  }
 
  void insert_cells(
    const std::unordered_set<CoMMAIndexType> &fcs,
    const std::optional<CoMMAIntType> new_compactness
  ) override {
    // As base class...
    this->_s_fc.insert(fcs.begin(), fcs.end());
    this->_cardinality += fcs.size();
    this->_compactness = new_compactness.has_value()
      ? new_compactness.value()
      : this->_fc_graph->compute_min_fc_compactness_inside_a_cc(this->_s_fc);
    // ...but now add to the subgraph
    for (const auto &i_fc : fcs) {
      _cc_graph->insert_node(
        this->_fc_graph->get_neighbours(i_fc),
        i_fc,
        this->_fc_graph->_volumes[i_fc],
        this->_fc_graph->get_weights(i_fc)
      );
    }
  }
 
  inline void update_connectivity() {
    _is_connected = _cc_graph->check_connectivity();
    _is_connectivity_up_to_date = true;
  }
 
  SubGraphPtr _cc_graph;
 
  bool _is_connected;
 
  bool _is_connectivity_up_to_date;
};
 
}  // end namespace comma
 
#endif  // COMMA_PROJECT_COARSE_CELL_H