ItemConnectivity.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemConnectivity.h                                          (C) 2000-2023 */
/*                                                                           */
/* External connectivities. First version with DoF                           */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_MESH_ITEMCONNECTIVITY_H
#define ARCANE_MESH_ITEMCONNECTIVITY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/ITraceMng.h"
 
#include "arcane/core/IItemFamily.h"
#include "arcane/core/ItemVector.h"
#include "arcane/core/VariableTypes.h"
#include "arcane/core/ItemInternal.h"
#include "arcane/core/IItemConnectivity.h"
#include "arcane/core/ConnectivityItemVector.h"
 
#include "arcane/mesh/DoFFamily.h"
#include "arcane/mesh/ItemProperty.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_MESH_EXPORT AbstractConnectivity
: public IItemConnectivity
{
 public:
 
  AbstractConnectivity(IItemFamily* source_family, IItemFamily* target_family, const String& connectivity_name)
  : m_source_family(source_family)
  , m_target_family(target_family)
  , m_name(connectivity_name)
  {
    m_families.add(m_source_family);
    m_families.add(m_target_family);
  }
 
 public:
 
  virtual const String& name() const
  {
    return m_name;
  }
 
 public:
 
  virtual ConstArrayView<IItemFamily*> families() const { return m_families.constView(); }
  virtual IItemFamily* sourceFamily() const { return m_source_family; }
  virtual IItemFamily* targetFamily() const { return m_target_family; }
  virtual void _initializeStorage(ConnectivityItemVector*)
  {
    // For now does nothing. Eventually, this can be used, for example,
    // to dimension the storage based on the maximum number of connected entities
    // to avoid reallocations when retrieving entities via _connectedItems().
  }
 
 protected:
 
  ConstArrayView<IItemFamily*> _families() const { return m_families.constView(); }
  IItemFamily* _sourceFamily() const { return m_source_family; }
  IItemFamily* _targetFamily() const { return m_target_family; }
 
 private:
 
  IItemFamily* m_source_family;
  IItemFamily* m_target_family;
  SharedArray<IItemFamily*> m_families;
  String m_name;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_MESH_EXPORT ItemConnectivity
: public AbstractConnectivity
{
 public:
 
  typedef ItemScalarProperty<Int32> ItemPropertyType;
 
 public:
 
  ItemConnectivity(IItemFamily* source_family, IItemFamily* target_family, const String& aname)
  : AbstractConnectivity(source_family, target_family, aname)
  {
    compute();
  }
 
  ItemConnectivity(IItemFamily* source_family, IItemFamily* target_family, const ItemPropertyType& item_property, const String& aname)
  : AbstractConnectivity(source_family, target_family, aname) // IFPEN: see the own parameter of GE...
  {
    m_item_property.copy(item_property);
  }
 
 public:
 
  virtual ItemVectorView _connectedItems(ItemLocalId item, ConnectivityItemVector& con_items) const
  {
    ARCANE_ASSERT((con_items.accessor() == this), ("Bad connectivity"));
    return con_items.setItem(m_item_property[item]);
  }
 
  virtual ConnectivityItemVectorCatalyst _connectedItems(ItemLocalId item) const
  {
    auto set = [this](ConnectivityItemVector& civ) mutable { civ = ConnectivityItemVector((ItemConnectivity*)this); };
    auto apply = [this, item](ConnectivityItemVector& civ) { this->_connectedItems(item, civ); };
    return { set, apply };
  }
 
  virtual void updateConnectivity(Int32ConstArrayView from_items, Int32ConstArrayView to_items);
 
 public:
 
  const Item operator()(ItemLocalId item) const
  {
    /*
    ARCANE_ASSERT((m_item_property[item] != NULL_ITEM_LOCAL_ID),
                  ("Item must be connected to one item in ItemConnectivity."));
    //TODO: keep ItemInternalList for performance reasons.
    return Item(_targetFamily()->itemsInternal()[m_item_property[item]]);
    */
    // Needed for IFPEN applicative test: eventually returns a null item (reasonable for perf ?)
    if (m_item_property[item] != NULL_ITEM_LOCAL_ID)
      return _targetFamily()->itemInfoListView()[m_item_property[item]];
    return Item();
  }
 
  ItemScalarProperty<Int32>& itemProperty() { return m_item_property; }
 
  void updateItemProperty(const ItemScalarProperty<Int32>& item_property) { m_item_property.copy(item_property); }
 
  virtual Integer nbConnectedItem(ItemLocalId lid) const
  {
    ARCANE_UNUSED(lid);
    return 1;
  }
 
  virtual Int32 connectedItemLocalId(ItemLocalId lid, [[maybe_unused]] Integer index) const
  {
    ARCANE_ASSERT((index == 0), ("Invalid value for index"))
    return m_item_property[lid];
  }

  virtual void notifySourceFamilyLocalIdChanged(Int32ConstArrayView new_to_old_ids)
  {
    m_item_property.updateSupport(new_to_old_ids);
  }

  virtual void notifyTargetFamilyLocalIdChanged(Int32ConstArrayView old_to_new_ids);
 
 private:
 
  ItemScalarProperty<Int32> m_item_property;
  SharedArray<ItemInternal*> m_item_internals;
 
 private:
 
  void compute();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class FromItemType, class ToItemType>
class ItemConnectivityT
: public ItemConnectivity
{
 public:
 
  typedef typename FromItemType::LocalIdType FromLocalIdType;
 
 public:
 
  ItemConnectivityT(IItemFamily* source_family, IItemFamily* target_family, const String& connectivity_name)
  : ItemConnectivity(source_family, target_family, connectivity_name)
  {}
 
  ItemConnectivityT(IItemFamily* source_family, IItemFamily* target_family, const ItemPropertyType& item_property, const String& connectivity_name)
  : ItemConnectivity(source_family, target_family, item_property, connectivity_name)
  {}
 
 public:
 
  const ToItemType operator()(FromLocalIdType item) const
  {
    return ItemConnectivity::operator()(item).itemBase();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ARCANE_MESH_EXPORT ItemArrayConnectivity
: public AbstractConnectivity
{
 public:
 
  typedef ItemArrayProperty<Int32> ItemPropertyType;
 
 public:
 
  ItemArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family, Integer nb_dof_per_item, const String& name)
  : AbstractConnectivity(source_family, target_family, name)
  , m_nb_dof_per_item(nb_dof_per_item)
  {
    compute();
  }
 
  ItemArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family, const ItemPropertyType& item_property, const String& name)
  : AbstractConnectivity(source_family, target_family, name)
  , m_nb_dof_per_item(item_property.dim2Size())
  {
    m_item_property.copy(item_property);
  }
 
 public:
 
  virtual ItemVectorView _connectedItems(ItemLocalId item, ConnectivityItemVector& con_items) const
  {
    return this->operator()(item, con_items);
  }
 
  virtual ConnectivityItemVectorCatalyst _connectedItems(ItemLocalId item) const
  {
    return this->operator()(item);
  }
 
  virtual void updateConnectivity(Int32ConstArrayView from_items, Int32ConstArrayView to_items);
 
 public:
 
  ItemArrayProperty<Int32>& itemProperty() { return m_item_property; }
 
  void updateItemProperty(const ItemArrayProperty<Int32>& item_property) { m_item_property.copy(item_property); }
 
  ItemVectorView operator()(ItemLocalId item, ConnectivityItemVector& con_items) const
  {
    ARCANE_ASSERT((con_items.accessor() == this), ("Bad connectivity"));
    return con_items.resizeAndCopy(m_item_property[item]);
  }
 
  ConnectivityItemVectorCatalyst operator()(ItemLocalId item) const
  {
    auto set = [this](ConnectivityItemVector& civ) mutable { civ = ConnectivityItemVector((ItemConnectivity*)this); };
    auto apply = [this, item](ConnectivityItemVector& civ) { this->operator()(item, civ); };
    return { set, apply };
  }
 
  virtual Integer nbConnectedItem(ItemLocalId lid) const
  {
    ARCANE_UNUSED(lid);
    return m_nb_dof_per_item;
  }
 
  virtual Int32 connectedItemLocalId(ItemLocalId lid, Integer index) const
  {
    return m_item_property[lid][index];
  }

  virtual void notifySourceFamilyLocalIdChanged(Int32ConstArrayView new_to_old_ids)
  {
    m_item_property.updateSupport(new_to_old_ids);
  }

  virtual void notifyTargetFamilyLocalIdChanged(Int32ConstArrayView old_to_new_ids);
 
 private:
 
  Integer m_nb_dof_per_item;
  ItemArrayProperty<Int32> m_item_property;
 
 private:
 
  void compute();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class FromItemType, class ToItemType>
class ItemArrayConnectivityT
: public ItemArrayConnectivity
{
 public:
 
  typedef typename FromItemType::LocalIdType FromLocalIdType;
 
 public:
 
  ItemArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family, Integer nb_dof_per_item, const String& connectivity_name)
  : ItemArrayConnectivity(source_family, target_family, nb_dof_per_item, connectivity_name)
  {}
 
  ItemArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family, const ItemPropertyType& item_property, const String& connectivity_name)
  : ItemArrayConnectivity(source_family, target_family, item_property, connectivity_name)
  {}
 
  ItemVectorView operator()(FromLocalIdType item, ConnectivityItemVector& con_items) const
  {
    return ItemArrayConnectivity::operator()(item, con_items);
  }
 
  ConnectivityItemVectorCatalyst operator()(FromLocalIdType item) const
  {
    return ItemArrayConnectivity::operator()(item);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ARCANE_MESH_EXPORT ItemMultiArrayConnectivity
: public AbstractConnectivity
{
 public:
 
  typedef ItemMultiArrayProperty<Int32> ItemPropertyType;
 
 public:
 
  ItemMultiArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family, IntegerConstArrayView nb_dof_per_item, const String& name)
  : AbstractConnectivity(source_family, target_family, name)
  {
    compute(nb_dof_per_item);
  }
 
  ItemMultiArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family, const ItemPropertyType& item_property, const String& name)
  : AbstractConnectivity(source_family, target_family, name)
  {
    m_item_property.copy(item_property);
  }
 
 public:
 
  virtual ItemVectorView _connectedItems(ItemLocalId item, ConnectivityItemVector& con_items) const
  {
    return this->operator()(item, con_items);
  }
 
  virtual ConnectivityItemVectorCatalyst _connectedItems(ItemLocalId item) const
  {
    return this->operator()(item);
  }
 
  virtual void updateConnectivity(Int32ConstArrayView from_items, Int32ConstArrayView to_items);
 
 public:
 
  ItemMultiArrayProperty<Int32>& itemProperty() { return m_item_property; }
 
  void updateItemProperty(ItemMultiArrayProperty<Int32>& item_property) { m_item_property.copy(item_property); }
 
  ItemVectorView operator()(ItemLocalId item, ConnectivityItemVector& con_items) const
  {
    ARCANE_ASSERT((con_items.accessor() == this), ("Bad connectivity"));
    return con_items.resizeAndCopy(m_item_property[item]);
  }
 
  ConnectivityItemVectorCatalyst operator()(ItemLocalId item) const
  {
    auto set = [this](ConnectivityItemVector& civ) mutable { civ = ConnectivityItemVector((ItemConnectivity*)this); };
    auto apply = [this, item](ConnectivityItemVector& civ) { this->operator()(item, civ); };
    return { set, apply };
  }
 
  virtual Integer nbConnectedItem(ItemLocalId lid) const
  {
    return m_item_property[lid].size();
  }
 
  virtual Int32 connectedItemLocalId(ItemLocalId lid, Integer index) const
  {
    return m_item_property[lid][index];
  }

  virtual void notifySourceFamilyLocalIdChanged(Int32ConstArrayView new_to_old_ids)
  {
    m_item_property.updateSupport(new_to_old_ids);
  }

  virtual void notifyTargetFamilyLocalIdChanged(Int32ConstArrayView old_to_new_ids);
 
 private:
 
  ItemMultiArrayProperty<Int32> m_item_property;
 
 private:
 
  void compute(IntegerConstArrayView nb_dof_per_item);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class FromItemType, class ToItemType>
class ItemMultiArrayConnectivityT
: public ItemMultiArrayConnectivity
{
 public:
 
  typedef typename FromItemType::LocalIdType FromLocalIdType;
 
 public:
 
  ItemMultiArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family, const IntegerConstArrayView nb_dof_per_item, const String& connectivity_name)
  : ItemMultiArrayConnectivity(source_family, target_family, nb_dof_per_item, connectivity_name)
  {}
 
  ItemMultiArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family, const ItemPropertyType& item_property, const String& connectivity_name)
  : ItemMultiArrayConnectivity(source_family, target_family, item_property, connectivity_name)
  {}
 
 public:
 
  ItemVectorViewT<ToItemType> operator()(FromLocalIdType item, ConnectivityItemVector& con_items) const
  {
    return ItemMultiArrayConnectivity::operator()(item, con_items);
  }
 
  ConnectivityItemVectorCatalyst operator()(ItemLocalId item) const
  {
    return ItemMultiArrayConnectivity::operator()(item);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif