ItemProperty.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemProperty.h                                             (C) 2000-2024  */
/*                                                                           */
/* Property on item to handle new connectivities and future mesh properties  */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_DOF_ITEMPROPERTY_H
#define ARCANE_DOF_ITEMPROPERTY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include <algorithm>
 
#include "arcane/utils/Array.h"
#include "arcane/utils/Array2.h"
#include "arcane/utils/MultiArray2.h"
#include "arcane/core/ArcaneTypes.h"
#include "arcane/core/IItemFamily.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class DataType>
class ItemScalarProperty
{
 public:

  ItemScalarProperty()
  : m_default_value(DataType())
  {}
 
 public:
 
  template <class AbstractFamily>
  void resize(AbstractFamily* item_family, const DataType default_value) // SDC Template AbstractFamily necessary for IFPEN applications
  {
    m_data.resize(item_family->maxLocalId(), default_value);
    m_default_value = default_value;
  }
 
  Integer size() const { return m_data.size(); }
 
  template <class AbstractItem>
  DataType& operator[](const AbstractItem item) { return m_data[item.localId()]; }
 
  template <class AbstractItem>
  DataType operator[](const AbstractItem item) const { return m_data[item.localId()]; }
 
  void print() const
  {
    std::cout << "== CONNECTIVITY ITEM PROPERTY CONTAINS " << std::endl;
    for (Arcane::Integer i = 0; i < m_data.size(); ++i) {
      std::cout << "\"" << m_data[i] << "\"" << std::endl;
    }
    std::cout << std::endl;
  }
 
  ConstArrayView<DataType> view() { return m_data.constView(); }
 
  void updateSupport(Int32ConstArrayView new_to_old_ids)
  {
    if (new_to_old_ids.size() == 0)
      return;
    UniqueArray<DataType> old_data(m_data);
    Integer new_size = new_to_old_ids.size();
    m_data.resize(new_size);
    // resize old_data with item recently added and not yet in connectivity
    // this max size can be greater than new size if they were add and remove
    Integer max_size = *(std::max_element(new_to_old_ids.begin(), new_to_old_ids.end())) + 1;
    if (max_size > old_data.size())
      old_data.resize(max_size, m_default_value); // padd new items
    for (Integer i = 0; i < new_size; ++i) {
      m_data[i] = old_data[new_to_old_ids[i]];
    }
  }
 
  void copy(const ItemScalarProperty<DataType>& item_property_from)
  {
    m_data.copy(item_property_from.m_data); // copy values
    m_default_value = item_property_from.m_default_value;
  }
 
 private:
 
  //  UniqueArray<DataType> m_data;
  SharedArray<DataType> m_data; // ItemProperty used in IFPEN applications as a shared object (Arcane-like...).
  DataType m_default_value;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class DataType>
class ItemArrayProperty
{
 public:

  ItemArrayProperty() {}
 
 public:
 
  template <class AbstractFamily>
  void resize(AbstractFamily* item_family, const Integer nb_element_per_item, const DataType default_value) // SDC Template AbstractFamily necessary for IFPEN applications
  {
    Integer dim1_old_size = m_data.dim1Size();
    Integer dim2_old_size = m_data.dim2Size();
    Integer dim1_new_size = item_family->maxLocalId();
    Integer dim2_new_size = nb_element_per_item;
    m_data.resize(dim1_new_size, dim2_new_size);
    // Fill new data
    // if new dim 1 larger, enter loop
    for (Integer i = dim1_old_size; i < dim1_new_size; ++i) {
      for (Integer j = 0; j < dim2_new_size; ++j)
        m_data[i][j] = default_value;
    }
    // test if dim2 larger before loop
    if (dim2_new_size > dim2_old_size) {
      for (Arcane::Integer i = 0; i < dim1_old_size; ++i) {
        for (Integer j = dim2_old_size; j < dim2_new_size; ++j)
          m_data[i][j] = default_value;
      }
    }
  }
 
  Integer dim1Size() const { return m_data.dim1Size(); }
  Integer dim2Size() const { return m_data.dim2Size(); }
 
  template <class AbstractItem>
  ArrayView<DataType> operator[](AbstractItem item) { return m_data[item.localId()]; }
 
  template <class AbstractItem>
  ConstArrayView<DataType> operator[](AbstractItem item) const { return m_data[item.localId()]; }
 
  void updateSupport(Int32ConstArrayView new_to_old_ids)
  {
    if (new_to_old_ids.size() == 0)
      return;
    UniqueArray2<DataType> old_data(m_data);
    Integer new_dim1_size = new_to_old_ids.size();
    Integer dim2_size = m_data.dim2Size();
    m_data.resize(new_dim1_size);
    // resize old_data with item recently added and not yet in connectivity
    // this max_dim1_size size can be greater than new_dim1_size if they were add and remove
    auto max_dim1_size = *(std::max_element(new_to_old_ids.begin(), new_to_old_ids.end())) + 1;
    old_data.resize(max_dim1_size); // padd for new items with 0 (not connected)
    for (Integer i = 0; i < new_dim1_size; ++i) {
      for (Integer j = 0; j < dim2_size; ++j)
        m_data[i][j] = old_data[new_to_old_ids[i]][j];
    }
  }
 
  void copy(const ItemArrayProperty<DataType>& item_property_from)
  {
    m_data.copy(item_property_from.m_data); // copy values
  }
 
 private:
 
  UniqueArray2<DataType> m_data;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class DataType>
class ItemMultiArrayProperty
{
 public:

  ItemMultiArrayProperty() {}
 
 public:
 
  typedef MultiArray2<DataType> InternalArray2;
 
  // nb_element per item est de taille IItemFamily::maxLocalId
  template <class AbstractFamily>
  void resize([[maybe_unused]] AbstractFamily* item_family,
              const Arcane::IntegerConstArrayView nb_element_per_item,
              const DataType default_value) // SDC Template AbstractFamily necessary for IFPEN applications
  {
    ARCANE_ASSERT((nb_element_per_item.size() == item_family->maxLocalId()),
                  ("In item property resize : nb_element_per_item must have size IItemFamilyy::maxLocalId"))
    Integer dim1_old_size = m_data.dim1Size();
    Integer dim1_new_size = nb_element_per_item.size();
    IntegerUniqueArray dim2_old_sizes(m_data.dim2Sizes());
    IntegerConstArrayView dim2_new_sizes(nb_element_per_item);
    m_data.resize(nb_element_per_item);
    // Fill new data with default value
    // Dim1 size larger
    for (Arcane::Integer i = dim1_old_size; i < dim1_new_size; ++i) {
      for (Arcane::Integer j = 0; j < dim2_new_sizes[i]; ++j) {
        m_data[i][j] = default_value;
      }
    }
    // Dim2 size larger (eventually, cannot know a priori, need to loop).
    for (Arcane::Integer i = 0; i < dim1_old_size; ++i) {
      for (Arcane::Integer j = dim2_old_sizes[i]; j < dim2_new_sizes[i]; ++j) {
        m_data[i][j] = default_value;
      }
    }
  }
 
  Integer dim1Size() const { return m_data.dim1Size(); }
  IntegerConstArrayView dim2Sizes() const { return m_data.dim2Sizes(); }
 
  template <class AbstractItem>
  ArrayView<DataType> operator[](const AbstractItem item) { return m_data[item.localId()]; }
 
  template <class AbstractItem>
  ConstArrayView<DataType> operator[](const AbstractItem item) const { return m_data[item.localId()]; }
 
  void updateSupport(Int32ConstArrayView new_to_old_ids)
  {
    if (new_to_old_ids.size() == 0)
      return;
    UniqueMultiArray2<DataType> old_data(m_data);
    Integer new_dim1_size = new_to_old_ids.size();
    // new_to_old_ids may refer to items newly added and not yet in m_data (ie old_data) if there is add and removal in the same event
    // compute max_dim1_size to take this into account
    Integer max_dim1_size = *(std::max_element(new_to_old_ids.begin(), new_to_old_ids.end())) + 1;
    IntegerUniqueArray dim2_sizes(m_data.dim2Sizes());
    dim2_sizes.resize(max_dim1_size, 1); // padd for unknown items with 1 (connected with empty)
    old_data.resize(dim2_sizes); // take into account unknown items. Recall these items are compacted but were not yet in m_data
    IntegerUniqueArray new_dim2_sizes(new_dim1_size);
    // Compute new sizes
    for (Integer i = 0; i < new_dim1_size; ++i) {
      new_dim2_sizes[i] = dim2_sizes[new_to_old_ids[i]];
    }
    m_data.resize(new_dim2_sizes);
    for (Integer i = 0; i < new_dim1_size; ++i) {
      for (Integer j = 0; j < new_dim2_sizes[i]; ++j)
        m_data[i][j] = old_data[new_to_old_ids[i]][j];
    }
  }
 
  void copy(const ItemMultiArrayProperty<DataType>& item_property_from)
  {
    m_data = item_property_from.m_data.constView(); // copy values
  }
 
 private:
 
  //  UniqueMultiArray2<DataType> m_data;
  SharedMultiArray2<DataType> m_data; // ItemProperty used in IFPEN applications as a shared object (Arcane-like...).
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif