core/materials/MatItemEnumerator.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MatItemEnumerator.h                                         (C) 2000-2024 */
/*                                                                           */
/* Enumérateurs sur les mailles materiaux.                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_MATERIALS_MATITEMENUMERATOR_H
#define ARCANE_CORE_MATERIALS_MATITEMENUMERATOR_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#include "arcane/utils/FatalErrorException.h"
 
#include "arcane/core/materials/MatItem.h"
#include "arcane/core/materials/IEnumeratorTracer.h"
 
#include "arcane/EnumeratorTraceWrapper.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifdef ARCANE_COMPONENT_arcane_materials
#ifndef ARCANE_TRACE_ENUMERATOR
#define ARCANE_TRACE_ENUMERATOR
#endif
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Materials
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class MatCellVector;
class EnvCellVector;
class ComponentItemVector;
class ComponentItemVectorView;
class ComponentPartItemVectorView;
class MatItemVectorView;
class EnvItemVectorView;
 
// Les 4 classes suivantes servent uniquement pour spécialiser
// ComponentItemEnumeratorTraitsT
class MatPartCell {};
class EnvPartCell {};
class ComponentPartCell {};
class ComponentPartSimdCell {};
 
template<typename T> class ComponentItemEnumeratorTraitsT;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT AllEnvCellVectorView
{
  friend class MeshMaterialMng;
 
 protected:
 
  AllEnvCellVectorView(Int32ConstArrayView local_ids,
                       ComponentItemSharedInfo* shared_info)
  : m_local_ids(local_ids)
  , m_shared_info(shared_info)
  {
  }
 
 public:
 
  constexpr ARCCORE_HOST_DEVICE Integer size() const { return m_local_ids.size(); }
 
  // \i ème maille du vecteur
  ARCCORE_HOST_DEVICE AllEnvCell operator[](Integer index) const
  {
    return AllEnvCell(m_shared_info->_item(ConstituentItemIndex(m_local_ids[index])));
  }
 
  // localId() de la \i ème maille du vecteur
  ARCCORE_HOST_DEVICE Int32 localId(Integer index) const { return m_local_ids[index]; }
 
 private:
 
  Int32ConstArrayView m_local_ids;
  ComponentItemSharedInfo* m_shared_info = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ComponentCellEnumerator
{
  friend class EnumeratorTracer;
 
 protected:
 
  explicit ComponentCellEnumerator(const ComponentItemVectorView& v);
 
 public:
 
  static ComponentCellEnumerator create(IMeshComponent* component);
  static ComponentCellEnumerator create(const ComponentItemVector& v);
  static ComponentCellEnumerator create(ComponentItemVectorView v);
 
 public:
 
  void operator++()
  {
    ++m_index;
#ifdef ARCANE_CHECK
    if (m_index<m_size)
      _check();
#endif
  }
  bool hasNext() const { return m_index<m_size; }
 
  ComponentCell operator*() const
  {
    return ComponentCell(m_constituent_list_view._constituenItemBase(m_index));
  }
 
  Integer index() const { return m_index; }
  MatVarIndex _varIndex() const { return m_matvar_indexes[m_index]; }
 
  operator ComponentItemLocalId() const
  {
    return ComponentItemLocalId(m_matvar_indexes[m_index]);
  }
 
 protected:
 
  Int32 _varArrayIndex() const { return m_matvar_indexes[m_index].arrayIndex(); }
  Int32 _varValueIndex() const { return m_matvar_indexes[m_index].valueIndex(); }
 
 protected:
 
  void _check() const
  {
    MatVarIndex mvi = m_constituent_list_view._matVarIndex(m_index);
    Int32 i_var_array_index = mvi.arrayIndex();
    Int32 mv_array_index = _varArrayIndex();
    if (i_var_array_index!=mv_array_index)
      ARCANE_FATAL("Bad 'var_array_index' in ComponentCell matvar='{0}' registered='{1}' index={2}",
                   mvi,m_matvar_indexes[m_index],m_index);
    Int32 i_var_value_index = mvi.valueIndex();
    Int32 mv_value_index = _varValueIndex();
    if (i_var_value_index!=mv_value_index)
      ARCANE_FATAL("Bad 'var_value_index' for ComponentCell matvar='{0}' registered='{1}' index={2}",
                   mvi,m_matvar_indexes[m_index],m_index);
  }
 
 protected:
 
  Int32 m_index;
  Int32 m_size;
  ConstituentItemLocalIdListView m_constituent_list_view;
  ConstArrayView<MatVarIndex> m_matvar_indexes;
  IMeshComponent* m_component;
 
 protected:
 
  matimpl::ConstituentItemBase _currentConstituentItemBase() const
  {
    return m_constituent_list_view._constituenItemBase(m_index);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT MatCellEnumerator
: public ComponentCellEnumerator
{
 protected:
 
  explicit MatCellEnumerator(const ComponentItemVectorView& v)
  : ComponentCellEnumerator(v)
  {
  }
 
 public:
 
  static MatCellEnumerator create(IMeshMaterial* mat);
  static MatCellEnumerator create(const MatCellVector& miv);
  static MatCellEnumerator create(MatItemVectorView v);
 
 public:
 
  MatCell operator*() const
  {
#ifdef ARCANE_CHECK
    _check();
#endif
    return MatCell(_currentConstituentItemBase());
  }
 
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT EnvCellEnumerator
: public ComponentCellEnumerator
{
 protected:
 
  explicit EnvCellEnumerator(const ComponentItemVectorView& v)
  : ComponentCellEnumerator(v)
  {
  }
 
 public:
 
  static EnvCellEnumerator create(IMeshEnvironment* mat);
  static EnvCellEnumerator create(const EnvCellVector& miv);
  static EnvCellEnumerator create(EnvItemVectorView v);
 
 public:
 
  EnvCell operator*() const
  {
#ifdef ARCANE_CHECK
    _check();
#endif
    return EnvCell(_currentConstituentItemBase());
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ComponentPartCellEnumerator
{
 protected:
 
  ComponentPartCellEnumerator(const ComponentPartItemVectorView& view,Integer base_index);
 
 public:
 
  static ComponentPartCellEnumerator create(ComponentPartItemVectorView v);
  static ComponentPartCellEnumerator create(IMeshComponent* c,eMatPart part);
 
 public:
 
 void operator++()
  {
    ++m_index;
  }
  bool hasNext() const { return m_index<m_size; }
 
  MatVarIndex _varIndex() const { return MatVarIndex(m_var_idx,m_value_indexes[m_index]); }
 
  operator ComponentItemLocalId() const
  {
    return ComponentItemLocalId(_varIndex());
  }
 
  ComponentCell operator*() const
  {
    return ComponentCell(m_constituent_list_view._constituenItemBase(m_item_indexes[m_index]));
  }
 
 protected:
 
  Integer m_index;
  Integer m_size;
  Integer m_var_idx;
  Integer m_base_index;
  Int32ConstArrayView m_value_indexes;
  Int32ConstArrayView m_item_indexes;
  ConstituentItemLocalIdListView m_constituent_list_view;
  IMeshComponent* m_component;
 
 protected:
 
  matimpl::ConstituentItemBase _currentConstituentItemBase() const
  {
    return m_constituent_list_view._constituenItemBase(m_item_indexes[m_index]);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT MatPartCellEnumerator
: public ComponentPartCellEnumerator
{
 public:
  explicit MatPartCellEnumerator(const MatPartItemVectorView& v);
 public:
  static MatPartCellEnumerator create(MatPartItemVectorView v);
  static MatPartCellEnumerator create(IMeshMaterial* mat,eMatPart part);
 public:
 
  MatCell operator*() const
  {
    return MatCell(_currentConstituentItemBase());
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT  EnvPartCellEnumerator
: public ComponentPartCellEnumerator
{
 public:
  explicit EnvPartCellEnumerator(const EnvPartItemVectorView& v);
 public:
  static EnvPartCellEnumerator create(EnvPartItemVectorView v);
  static EnvPartCellEnumerator create(IMeshEnvironment* env,eMatPart part);
 public:
 
  EnvCell operator*() const
  {
    return EnvCell(_currentConstituentItemBase());
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT CellGenericEnumerator
{
 public:
  static EnvCellEnumerator create(IMeshEnvironment* env);
  static EnvCellEnumerator create(const EnvCellVector& ecv);
  static EnvCellEnumerator create(EnvItemVectorView v);
 
  static MatCellEnumerator create(IMeshMaterial* mat);
  static MatCellEnumerator create(const MatCellVector& miv);
  static MatCellEnumerator create(MatItemVectorView v);
 
  static CellEnumerator create(CellVectorView v);
  static CellEnumerator create(const CellGroup& v);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT AllEnvCellEnumerator
{
  friend class EnumeratorTracer;
 protected:
  explicit AllEnvCellEnumerator(AllEnvCellVectorView items)
  : m_index(0), m_size(items.size()), m_items(items) { }
 public:
  static AllEnvCellEnumerator create(AllEnvCellVectorView items);
  static AllEnvCellEnumerator create(IMeshMaterialMng* mng,const CellGroup& group);
  static AllEnvCellEnumerator create(IMeshMaterialMng* mng,const CellVectorView& view);
  static AllEnvCellEnumerator create(IMeshBlock* block);
 public:
  void operator++() { ++m_index; }
  bool hasNext() const { return m_index<m_size; }
  AllEnvCell operator*() { return m_items[m_index]; }
  Integer index() const { return m_index; }
 public:
  Integer m_index;
  Integer m_size;
  AllEnvCellVectorView m_items;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ComponentEnumerator
{
  friend class EnumeratorTracer;
 
 public:
 
  explicit ComponentEnumerator(ConstArrayView<IMeshComponent*> components);
 
 public:
 
  bool hasNext() const { return m_index<m_size; }
  void operator++() { ++m_index; }
  IMeshComponent* operator*() const { return m_components[m_index]; }
 
 private:
 
  ConstArrayView<IMeshComponent*> m_components;
  Integer m_index;
  Integer m_size;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT MatEnumerator
{
 public:
 
  explicit MatEnumerator(IMeshMaterialMng* mng);
  explicit MatEnumerator(IMeshEnvironment* env);
  explicit MatEnumerator(ConstArrayView<IMeshMaterial*> mats);
 
 public:
 
  bool hasNext() const { return m_index<m_size; }
  void operator++() { ++m_index; }
  IMeshMaterial* operator*() const { return m_mats[m_index]; }
 
 private:
 
  ConstArrayView<IMeshMaterial*> m_mats;
  Integer m_index;
  Integer m_size;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT EnvEnumerator
{
 public:
 
  EnvEnumerator(IMeshMaterialMng* mng);
  EnvEnumerator(IMeshBlock* block);
  EnvEnumerator(ConstArrayView<IMeshEnvironment*> envs);
 
 public:
 
  bool hasNext() const { return m_index<m_size; }
  void operator++() { ++m_index; }
  IMeshEnvironment* operator*() const { return m_envs[m_index]; }
 
 private:
 
  ConstArrayView<IMeshEnvironment*> m_envs;
  Integer m_index;
  Integer m_size;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<>
class ComponentItemEnumeratorTraitsT<ComponentCell>
{
 public:
  using EnumeratorType = ComponentCellEnumerator;
};
template<>
class ComponentItemEnumeratorTraitsT<MatCell>
{
 public:
  using EnumeratorType = MatCellEnumerator;
};
template<>
class ComponentItemEnumeratorTraitsT<MatPartCell>
{
 public:
  using EnumeratorType = MatPartCellEnumerator;
};
template<>
class ComponentItemEnumeratorTraitsT<EnvPartCell>
{
 public:
  using EnumeratorType = EnvPartCellEnumerator;
};
template<>
class ComponentItemEnumeratorTraitsT<EnvCell>
{
 public:
  using EnumeratorType = EnvCellEnumerator;
};
template<>
class ComponentItemEnumeratorTraitsT<ComponentPartCell>
{
 public:
  using EnumeratorType = ComponentPartCellEnumerator;
};
template<>
class ComponentItemEnumeratorTraitsT<ComponentPartSimdCell>
{
 public:
  using EnumeratorType = ComponentPartSimdCellEnumerator;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#if defined(ARCANE_TRACE_ENUMERATOR)
#define A_TRACE_COMPONENT(_EnumeratorClassName) \
  ::Arcane::EnumeratorTraceWrapper< ::Arcane::Materials::_EnumeratorClassName, ::Arcane::Materials::IEnumeratorTracer >
#else
#define A_TRACE_COMPONENT(_EnumeratorClassName) \
  ::Arcane::Materials::_EnumeratorClassName
#endif
 
#define A_ENUMERATE_COMPONENTCELL(_EnumeratorClassName,iname,...) \
  for( A_TRACE_COMPONENT(_EnumeratorClassName) iname(Arcane::Materials::_EnumeratorClassName::create(__VA_ARGS__) A_TRACE_ENUMERATOR_WHERE); iname.hasNext(); ++iname )
 
#define A_ENUMERATE_COMPONENT(_EnumeratorClassName,iname,container) \
  for( A_TRACE_COMPONENT(_EnumeratorClassName) iname((::Arcane::Materials::_EnumeratorClassName)(container) A_TRACE_ENUMERATOR_WHERE); iname.hasNext(); ++iname )
 
#define A_ENUMERATE_CELL_COMPONENTCELL(_EnumeratorClassName,iname,component_cell) \
  for( ::Arcane::Materials::_EnumeratorClassName iname((::Arcane::Materials::_EnumeratorClassName)(component_cell)); iname.hasNext(); ++iname )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#define ENUMERATE_COMPONENTITEM(enumerator_class_name,iname,...)      \
  A_ENUMERATE_COMPONENTCELL(ComponentItemEnumeratorTraitsT<enumerator_class_name>::EnumeratorType,iname,__VA_ARGS__)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#define ENUMERATE_ALLENVCELL(iname,...) \
  for( A_TRACE_COMPONENT(AllEnvCellEnumerator) iname( ::Arcane::Materials::AllEnvCellEnumerator::create(__VA_ARGS__) ); iname.hasNext(); ++iname )
 
#define ENUMERATE_MATCELL(iname,mat) \
  A_ENUMERATE_COMPONENTCELL(MatCellEnumerator,iname,mat)
 
#define ENUMERATE_ENVCELL(iname,env) \
  A_ENUMERATE_COMPONENTCELL(EnvCellEnumerator,iname,env)
 
#define ENUMERATE_COMPONENTCELL(iname,component) \
  A_ENUMERATE_COMPONENTCELL(ComponentCellEnumerator,iname,component)
 
#define ENUMERATE_COMPONENT(icomponent,container) \
  A_ENUMERATE_COMPONENT(ComponentEnumerator,icomponent,container)
 
#define ENUMERATE_MAT(imat,container) \
  A_ENUMERATE_COMPONENT(MatEnumerator,imat,container)
 
#define ENUMERATE_ENV(ienv,container) \
  A_ENUMERATE_COMPONENT(EnvEnumerator,ienv,container)
 
#define ENUMERATE_CELL_COMPONENTCELL(iname,component_cell) \
  A_ENUMERATE_CELL_COMPONENTCELL(CellComponentCellEnumerator,iname,component_cell)
 
#define ENUMERATE_CELL_MATCELL(iname,env_cell) \
  A_ENUMERATE_CELL_COMPONENTCELL(CellMatCellEnumerator,iname,env_cell)
 
#define ENUMERATE_CELL_ENVCELL(iname,all_env_cell) \
  A_ENUMERATE_CELL_COMPONENTCELL(CellEnvCellEnumerator,iname,all_env_cell)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#define ENUMERATE_GENERIC_CELL(iname,mat_or_env_or_group) \
  for( auto iname = ::Arcane::Materials::CellGenericEnumerator::create(mat_or_env_or_group); iname.hasNext(); ++iname )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Materials
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif