da/dfa/MeshMaterialVariable_8h_source.html

// -*- 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

//-----------------------------------------------------------------------------

/*---------------------------------------------------------------------------*/

/* MeshMaterialVariable.h                                      (C) 2000-2024 */

/*                                                                           */

/* Variable on a mesh material.                                              */

/*---------------------------------------------------------------------------*/

#ifndef ARCANE_MATERIALS_MESHMATERIALVARIABLE_H

#define ARCANE_MATERIALS_MESHMATERIALVARIABLE_H

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#include "arcane/utils/NotImplementedException.h"

#include "arcane/utils/Array.h"

#include "arcane/utils/MemoryView.h"


#include "arcane/core/materials/IMeshMaterialVariable.h"

#include "arcane/core/materials/MatVarIndex.h"


#include "arcane/materials/MaterialsGlobal.h"


#include "arcane/materials/MeshMaterialVariableFactoryRegisterer.h"


#include "arcane/core/materials/IScalarMeshMaterialVariable.h"

#include "arcane/core/materials/IArrayMeshMaterialVariable.h"


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


namespace Arcane

{

class VariableInfo;

class VariableRef;

class VariableBuildInfo;

template <typename ItemType, typename DataTypeT> class MeshVariableScalarRefT;

} // namespace Arcane


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


namespace Arcane::Materials

{


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class MaterialVariableBuildInfo;

class MeshMaterialVariablePrivate;

class MeshMaterialVariableSynchronizerList;

class CopyBetweenPartialAndGlobalArgs;

class ResizeVariableIndexerArgs;

class InitializeWithZeroArgs;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


class ARCANE_MATERIALS_EXPORT MeshMaterialVariable

: public IMeshMaterialVariable

{

  friend MeshMaterialVariablePrivate;

  // For access to 'copyToBuffer', 'copyFromBuffer'. To be removed later

  friend MeshMaterialVariableSynchronizerList;


 public:


  MeshMaterialVariable(const MaterialVariableBuildInfo& v, MatVarSpace mvs);

  ~MeshMaterialVariable() override;


 public:


  String name() const override;

  void addVariableRef(MeshMaterialVariableRef* var_ref) override;

  void removeVariableRef(MeshMaterialVariableRef* var_ref) override;

  MeshMaterialVariableRef* firstReference() const override;

  IVariable* materialVariable(IMeshMaterial* mat) override;


  void setKeepOnChange(bool v) override;

  bool keepOnChange() const override;


  MatVarSpace space() const override;


 public:


  void update(IMeshMaterial* mat) override;

  void setUpToDate(IMeshMaterial* mat) override;

  Int64 modifiedTime(IMeshMaterial* mat) override;

  void addDepend(IMeshMaterialVariable* var) override;

  void addDepend(IMeshMaterialVariable* var, const TraceInfo& tinfo) override;

  void addDepend(IVariable* var) override;

  void addDepend(IVariable* var, const TraceInfo& tinfo) override;

  void removeDepend(IMeshMaterialVariable* var) override;

  void removeDepend(IVariable* var) override;

  void setComputeFunction(IMeshMaterialVariableComputeFunction* v) override;

  IMeshMaterialVariableComputeFunction* computeFunction() override;

  void dependInfos(Array<VariableDependInfo>& infos,

                   Array<MeshMaterialVariableDependInfo>& mat_infos) override;


  IMeshMaterialVariableInternal* _internalApi() override;


 public:


  virtual Int32 dataTypeSize() const = 0;


 protected:


  // TODO: obsolete interface to remove

  virtual void copyToBuffer(ConstArrayView<MatVarIndex> matvar_indexes, ByteArrayView bytes) const = 0;

  // TODO: obsolete interface to remove

  virtual void copyFromBuffer(ConstArrayView<MatVarIndex> matvar_indexes, ByteConstArrayView bytes) = 0;


 public:


  void incrementReference();


 protected:


  ITraceMng* _traceMng() const;


 protected:


  MeshMaterialVariablePrivate* m_p = nullptr;

  UniqueArray<Span<std::byte>> m_views_as_bytes;


 protected:


  void _copyToBuffer(SmallSpan<const MatVarIndex> matvar_indexes, Span<std::byte> bytes, RunQueue* queue) const;

  void _copyFromBuffer(SmallSpan<const MatVarIndex> matvar_indexes, Span<const std::byte> bytes, RunQueue* queue);


  virtual Ref<IData> _internalCreateSaveDataRef(Integer nb_value) = 0;

  virtual void _saveData(IMeshComponent* component, IData* data) = 0;

  virtual void _restoreData(IMeshComponent* component, IData* data, Integer data_index,

                            Int32ConstArrayView ids, bool allow_null_id) = 0;

  virtual void _copyBetweenPartialAndGlobal(const CopyBetweenPartialAndGlobalArgs& args) = 0;

  virtual void _initializeNewItemsWithZero(InitializeWithZeroArgs& args) = 0;

  virtual void _syncReferences(bool update_views) = 0;

  virtual void _resizeForIndexer(ResizeVariableIndexerArgs& args) = 0;


 private:


  static SmallSpan<const Int32> _toInt32Indexes(SmallSpan<const MatVarIndex> indexes);


 public:


  static void _genericCopyTo(Span<const std::byte> input,

                             SmallSpan<const Int32> input_indexes,

                             Span<std::byte> output,

                             SmallSpan<const Int32> output_indexes,

                             const RunQueue& queue, Int32 data_type_size);

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename DataType>


class MaterialVariableScalarTraits

{

 public:


  using ValueType = DataType;


  using SubViewType = DataType;

  using SubConstViewType = DataType;

  using SubInputViewType = DataType;

  using ContainerSpanType = SmallSpan<DataType>;

  using ContainerViewType = ArrayView<DataType>;

  using ContainerConstViewType = ConstArrayView<DataType>;

  using PrivatePartType = VariableArrayT<DataType>;

  using ValueDataType = IArrayDataT<DataType>;

  using ContainerType = Array<DataType>;

  using UniqueContainerType = UniqueArray<DataType>;

  using VariableRefType = VariableRefArrayT<DataType>;


 public:


  ARCANE_MATERIALS_EXPORT static void

  saveData(IMeshComponent* component, IData* data, Array<ContainerViewType>& cviews);

  ARCANE_MATERIALS_EXPORT static void

  copyTo(SmallSpan<const DataType> input, SmallSpan<const Int32> input_indexes,

         SmallSpan<DataType> output, SmallSpan<const Int32> output_indexes,

         const RunQueue& queue);

  ARCANE_MATERIALS_EXPORT static void

  resizeAndFillWithDefault(ValueDataType* data, ContainerType& container, Integer dim1_size);


  static ARCCORE_HOST_DEVICE void setValue(DataType& view, const DataType& v)

  {

    view = v;

  }

  ARCANE_MATERIALS_EXPORT static void

  resizeWithReserve(PrivatePartType* var, Int32 new_size, Real reserve_ratio);

  static Integer dimension() { return 0; }

  static SmallSpan<std::byte> toBytes(ArrayView<DataType> view)

  {

    //SmallSpan<DataType> s(view);

    return asWritableBytes(view);

  }

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename DataType>


class MaterialVariableArrayTraits

{

 public:


  using ValueType = DataType;


  using SubViewType = ArrayView<DataType>;

  using SubConstViewType = ConstArrayView<DataType>;

  using SubInputViewType = SmallSpan<const DataType>;

  using ContainerViewType = Array2View<DataType>;

  using ContainerSpanType = SmallSpan2<DataType>;

  using ContainerConstViewType = ConstArray2View<DataType>;

  using PrivatePartType = Array2VariableT<DataType>;

  using ValueDataType = IArray2DataT<DataType>;

  using ContainerType = Array2<DataType>;

  using UniqueContainerType = UniqueArray2<DataType>;

  using VariableRefType = VariableRefArray2T<DataType>;


 public:


  ARCANE_MATERIALS_EXPORT

  static void saveData(IMeshComponent* component, IData* data,

                       Array<ContainerViewType>& cviews);

  ARCANE_MATERIALS_EXPORT

  static void copyTo(SmallSpan2<const DataType> input, SmallSpan<const Int32> input_indexes,

                     SmallSpan2<DataType> output, SmallSpan<const Int32> output_indexes,

                     const RunQueue& queue);

  ARCANE_MATERIALS_EXPORT

  static void resizeAndFillWithDefault(ValueDataType* data, ContainerType& container,

                                       Integer dim1_size);

  static ARCCORE_HOST_DEVICE void setValue(SmallSpan<DataType> view, const DataType& v)

  {

    view.fill(v);

  }

  static ARCCORE_HOST_DEVICE void setValue(SmallSpan<DataType> view, SmallSpan<const DataType> v)

  {

    view.copy(v);

  }

  ARCANE_MATERIALS_EXPORT

  static void resizeWithReserve(PrivatePartType* var, Integer new_size, Real resize_ratio);

  static SmallSpan<std::byte> toBytes(Array2View<DataType> view)

  {

    SmallSpan<DataType> s(view.data(), view.totalNbElement());

    return asWritableBytes(s);

  }


  static Integer dimension() { return 0; }

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename Traits>


class ItemMaterialVariableBase

: public MeshMaterialVariable

{

 public:


  using TraitsType = Traits;

  using ValueType = typename Traits::ValueType;

  using DataType = typename Traits::ValueType;

  using ThatClass = ItemMaterialVariableBase<Traits>;


  using SubViewType = typename Traits::SubViewType;

  using SubConstViewType = typename Traits::SubConstViewType;

  using SubInputViewType = typename Traits::SubInputViewType;

  using ContainerSpanType = typename Traits::ContainerSpanType;

  using ContainerViewType = typename Traits::ContainerViewType;

  using ContainerConstViewType = typename Traits::ContainerConstViewType;

  using PrivatePartType = typename Traits::PrivatePartType;

  using ValueDataType = typename Traits::ValueDataType;

  using ContainerType = typename Traits::ContainerType;

  using UniqueContainerType = typename Traits::UniqueContainerType;

  using VariableRefType = typename Traits::VariableRefType;


 public:


  ARCANE_MATERIALS_EXPORT

  ItemMaterialVariableBase(const MaterialVariableBuildInfo& v,

                           PrivatePartType* global_var,

                           VariableRef* global_var_ref, MatVarSpace mvs);

  ARCANE_MATERIALS_EXPORT ~ItemMaterialVariableBase() override;


 public:


  ARCANE_MATERIALS_EXPORT void syncReferences() override;

  ARCANE_MATERIALS_EXPORT IVariable* globalVariable() const override;

  ARCANE_MATERIALS_EXPORT void buildFromManager(bool is_continue) override;


  ARCANE_MATERIALS_EXPORT Ref<IData> _internalCreateSaveDataRef(Integer nb_value) override;

  ARCANE_MATERIALS_EXPORT void _saveData(IMeshComponent* env, IData* data) override;

  ARCANE_MATERIALS_EXPORT

  void _restoreData(IMeshComponent* component, IData* data, Integer data_index,

                    Int32ConstArrayView ids, bool allow_null_id) override;

  ARCANE_MATERIALS_EXPORT

  void _copyBetweenPartialAndGlobal(const CopyBetweenPartialAndGlobalArgs& args) override;

  ARCANE_MATERIALS_EXPORT

  void _initializeNewItemsWithZero(InitializeWithZeroArgs& args) override;


  ARCANE_MATERIALS_EXPORT void fillPartialValuesWithGlobalValues() override;

  ARCANE_MATERIALS_EXPORT void

  fillPartialValuesWithSuperValues(Int32 level) override;


 public:


  void setValue(MatVarIndex mvi, SubInputViewType v)

  {

    Traits::setValue(m_host_views[mvi.arrayIndex()][mvi.valueIndex()], v);

  }


  void setFillValue(MatVarIndex mvi, const DataType& v)

  {

    Traits::setValue(m_host_views[mvi.arrayIndex()][mvi.valueIndex()], v);

  }


  SubConstViewType value(MatVarIndex mvi) const

  {

    return m_host_views[mvi.arrayIndex()][mvi.valueIndex()];

  }


 protected:


  void _syncFromGlobalVariable();

  PrivatePartType* _trueGlobalVariable()

  {

    return m_global_variable;

  }


  void _init(ArrayView<PrivatePartType*> vars);

  ARCANE_MATERIALS_EXPORT void

  _fillPartialValuesWithSuperValues(MeshComponentList components);

  ARCANE_MATERIALS_EXPORT void _syncReferences(bool check_resize) override;

  ARCANE_MATERIALS_EXPORT void _resizeForIndexer(ResizeVariableIndexerArgs& args) override;

  ARCANE_MATERIALS_EXPORT void _copyHostViewsToViews(RunQueue* queue);


 public:

 protected:


  PrivatePartType* m_global_variable = nullptr;

  VariableRef* m_global_variable_ref = nullptr;

  UniqueArray<PrivatePartType*> m_vars;

  UniqueArray<ContainerViewType> m_device_views;

  UniqueArray<ContainerViewType> m_host_views;


 protected:


  void _setView(Int32 index)

  {

    ContainerViewType view;

    if (m_vars[index])

      view = m_vars[index]->valueView();

    m_host_views[index] = view;

    m_views_as_bytes[index] = TraitsType::toBytes(view);

  }


 private:


  bool _isValidAndUsedAndGlobalUsed(PrivatePartType* partial_var);

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename TrueType>


class MeshMaterialVariableCommonStaticImpl

{

 public:


  static ARCANE_MATERIALS_EXPORT IMeshMaterialVariable*

  getReference(const MaterialVariableBuildInfo& v, MatVarSpace mvs);


 private:


  static ARCANE_MATERIALS_EXPORT IMeshMaterialVariable* _autoCreate1(const MaterialVariableBuildInfo& vb);

  static ARCANE_MATERIALS_EXPORT IMeshMaterialVariable* _autoCreate2(const MaterialVariableBuildInfo& vb);

  static ARCANE_MATERIALS_EXPORT MeshMaterialVariableFactoryRegisterer m_auto_registerer1;

  static ARCANE_MATERIALS_EXPORT MeshMaterialVariableFactoryRegisterer m_auto_registerer2;

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename DataType>


class ItemMaterialVariableScalar

: public ItemMaterialVariableBase<MaterialVariableScalarTraits<DataType>>

{

 public:


  using BaseClass = ItemMaterialVariableBase<MaterialVariableScalarTraits<DataType>>;

  using Traits = MaterialVariableScalarTraits<DataType>;

  using ThatClass = ItemMaterialVariableScalar<DataType>;


  using ContainerViewType = typename Traits::ContainerViewType;

  using PrivatePartType = typename Traits::PrivatePartType;

  using ValueDataType = typename Traits::ValueDataType;

  using ContainerType = typename Traits::ContainerType;

  using VariableRefType = typename Traits::VariableRefType;


 protected:


  ARCANE_MATERIALS_EXPORT

  ItemMaterialVariableScalar(const MaterialVariableBuildInfo& v,

                             PrivatePartType* global_var,

                             VariableRef* global_var_ref, MatVarSpace mvs);


 public:


  ArrayView<DataType>* views() { return this->m_host_views.data(); }


 protected:


  ArrayView<ArrayView<DataType>> _containerView() { return this->m_host_views; }


 public:


  DataType operator[](MatVarIndex mvi) const

  {

    return this->m_host_views[mvi.arrayIndex()][mvi.valueIndex()];

  }


  using BaseClass::setValue;

  using BaseClass::value;


  ARCANE_MATERIALS_EXPORT void synchronize() override;

  ARCANE_MATERIALS_EXPORT void synchronize(MeshMaterialVariableSynchronizerList& sync_list) override;

  ARCANE_MATERIALS_EXPORT void dumpValues(std::ostream& ostr) override;

  ARCANE_MATERIALS_EXPORT void dumpValues(std::ostream& ostr, AllEnvCellVectorView view) override;

  ARCANE_MATERIALS_EXPORT void serialize(ISerializer* sbuffer, Int32ConstArrayView ids) override;


 public:


  ARCANE_MATERIALS_EXPORT

  void fillFromArray(IMeshMaterial* mat, ConstArrayView<DataType> values);

  ARCANE_MATERIALS_EXPORT

  void fillFromArray(IMeshMaterial* mat, ConstArrayView<DataType> values,

                     Int32ConstArrayView indexes);

  ARCANE_MATERIALS_EXPORT void fillToArray(IMeshMaterial* mat, ArrayView<DataType> values);

  ARCANE_MATERIALS_EXPORT void fillToArray(IMeshMaterial* mat, ArrayView<DataType> values,

                                           Int32ConstArrayView indexes);

  ARCANE_MATERIALS_EXPORT void fillPartialValues(const DataType& value);


 private:


  ARCANE_MATERIALS_EXPORT Int32 dataTypeSize() const override;

  ARCANE_MATERIALS_EXPORT

  void copyToBuffer(ConstArrayView<MatVarIndex> matvar_indexes,

                    ByteArrayView bytes) const override;

  ARCANE_MATERIALS_EXPORT

  void copyFromBuffer(ConstArrayView<MatVarIndex> matvar_indexes,

                      ByteConstArrayView bytes) override;


 protected:


  using BaseClass::m_p;


 private:


  using BaseClass::m_global_variable;

  using BaseClass::m_global_variable_ref;

  using BaseClass::m_host_views;

  using BaseClass::m_vars;


 private:


  void _synchronizeV1();

  void _synchronizeV2();

  void _synchronizeV5();

  Int64 _synchronize2();


 private:


  void _copyToBufferLegacy(SmallSpan<const MatVarIndex> matvar_indexes,

                           Span<std::byte> bytes) const;

  void _copyFromBufferLegacy(SmallSpan<const MatVarIndex> matvar_indexes,

                             Span<const std::byte> bytes);

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename ItemType, typename DataType>


class MeshMaterialVariableScalar

: public ItemMaterialVariableScalar<DataType>

, public IScalarMeshMaterialVariable<ItemType, DataType>

{

 public:


  using ThatClass = MeshMaterialVariableScalar<ItemType, DataType>;

  using ThatInterface = IScalarMeshMaterialVariable<ItemType, DataType>;

  using BuilderType = typename ThatInterface::BuilderType;

  using StaticImpl = MeshMaterialVariableCommonStaticImpl<ThatClass>;

  using ItemTypeTemplate = ItemType;


  using BaseClass = ItemMaterialVariableScalar<DataType>;

  using VariableRefType = MeshVariableScalarRefT<ItemType, DataType>;

  using PrivatePartType = typename BaseClass::PrivatePartType;


  friend StaticImpl;


 protected:


  ARCANE_MATERIALS_EXPORT

  MeshMaterialVariableScalar(const MaterialVariableBuildInfo& v,

                             PrivatePartType* global_var,

                             VariableRefType* global_var_ref, MatVarSpace mvs);

  ARCANE_MATERIALS_EXPORT

  ~MeshMaterialVariableScalar();


 public:


  VariableRefType* globalVariableReference() const final { return m_true_global_variable_ref; }

  void incrementReference() final { BaseClass::incrementReference(); }

  ArrayView<ArrayView<DataType>> _internalFullValuesView() final { return BaseClass::_containerView(); }

  void fillFromArray(IMeshMaterial* mat, ConstArrayView<DataType> values) final

  {

    return BaseClass::fillFromArray(mat, values);

  }

  void fillFromArray(IMeshMaterial* mat, ConstArrayView<DataType> values, Int32ConstArrayView indexes) final

  {

    BaseClass::fillFromArray(mat, values, indexes);

  }

  void fillToArray(IMeshMaterial* mat, ArrayView<DataType> values) final

  {

    BaseClass::fillToArray(mat, values);

  }

  void fillToArray(IMeshMaterial* mat, ArrayView<DataType> values, Int32ConstArrayView indexes) final

  {

    BaseClass::fillToArray(mat, values, indexes);

  }

  void fillPartialValues(const DataType& value) final { BaseClass::fillPartialValues(value); }

  IMeshMaterialVariable* toMeshMaterialVariable() final { return this; }


 private:


  VariableRefType* m_true_global_variable_ref = nullptr;

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename DataType>


class ItemMaterialVariableArray

: public ItemMaterialVariableBase<MaterialVariableArrayTraits<DataType>>

{

 public:


  using BaseClass = ItemMaterialVariableBase<MaterialVariableArrayTraits<DataType>>;

  using Traits = MaterialVariableArrayTraits<DataType>;


  using ThatClass = ItemMaterialVariableArray<DataType>;


  using ContainerViewType = typename Traits::ContainerViewType;

  using PrivatePartType = typename Traits::PrivatePartType;

  using ValueDataType = typename Traits::ValueDataType;

  using ContainerType = typename Traits::ContainerType;

  using VariableRefType = typename Traits::VariableRefType;


 protected:


  ARCANE_MATERIALS_EXPORT

  ItemMaterialVariableArray(const MaterialVariableBuildInfo& v,

                            PrivatePartType* global_var,

                            VariableRef* global_var_ref, MatVarSpace mvs);


 public:


  ARCANE_DEPRECATED_REASON("Y2022: Do not use internal storage accessor")

  Array2View<DataType>* views() { return m_host_views.data(); }


 public:


  ARCANE_MATERIALS_EXPORT void synchronize() override;

  ARCANE_MATERIALS_EXPORT void synchronize(MeshMaterialVariableSynchronizerList& sync_list) override;

  ARCANE_MATERIALS_EXPORT void dumpValues(std::ostream& ostr) override;

  ARCANE_MATERIALS_EXPORT void dumpValues(std::ostream& ostr, AllEnvCellVectorView view) override;

  ARCANE_MATERIALS_EXPORT void serialize(ISerializer* sbuffer, Int32ConstArrayView ids) override;


 private:


  ARCANE_MATERIALS_EXPORT Int32 dataTypeSize() const override;


  ARCANE_MATERIALS_EXPORT

  void copyToBuffer(ConstArrayView<MatVarIndex> matvar_indexes,

                    ByteArrayView bytes) const override;


  ARCANE_MATERIALS_EXPORT

  void copyFromBuffer(ConstArrayView<MatVarIndex> matvar_indexes,

                      ByteConstArrayView bytes) override;


 public:


  ARCANE_MATERIALS_EXPORT void resize(Integer dim2_size);


 public:


  ConstArrayView<DataType> operator[](MatVarIndex mvi) const

  {

    return m_host_views[mvi.arrayIndex()][mvi.valueIndex()];

  }


  using BaseClass::setValue;

  using BaseClass::value;


 protected:


  using BaseClass::m_p;

  ArrayView<Array2View<DataType>> _containerView() { return m_host_views; }


 private:


  using BaseClass::m_global_variable;

  using BaseClass::m_global_variable_ref;

  using BaseClass::m_host_views;

  using BaseClass::m_vars;


  void _copyToBufferLegacy(SmallSpan<const MatVarIndex> matvar_indexes,

                           Span<std::byte> bytes) const;

  void _copyFromBufferLegacy(SmallSpan<const MatVarIndex> matvar_indexes,

                             Span<const std::byte> bytes);

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <typename ItemType, typename DataType>


class MeshMaterialVariableArray

: public ItemMaterialVariableArray<DataType>

, public IArrayMeshMaterialVariable<ItemType, DataType>

{

 public:


  using ThatClass = MeshMaterialVariableArray<ItemType, DataType>;

  using ThatInterface = IArrayMeshMaterialVariable<ItemType, DataType>;

  using BuilderType = typename ThatInterface::BuilderType;

  using StaticImpl = MeshMaterialVariableCommonStaticImpl<ThatClass>;

  using ItemTypeTemplate = ItemType;


  using BaseClass = ItemMaterialVariableArray<DataType>;

  using VariableRefType = MeshVariableArrayRefT<ItemType, DataType>;

  using PrivatePartType = typename BaseClass::PrivatePartType;


  friend StaticImpl;


 protected:


  ARCANE_MATERIALS_EXPORT

  MeshMaterialVariableArray(const MaterialVariableBuildInfo& v,

                            PrivatePartType* global_var,

                            VariableRefType* global_var_ref, MatVarSpace mvs);


 public:


  void incrementReference() final { BaseClass::incrementReference(); }

  ArrayView<Array2View<DataType>> _internalFullValuesView() final { return BaseClass::_containerView(); }

  void resize(Int32 dim2_size) final { BaseClass::resize(dim2_size); }

  VariableRefType* globalVariableReference() const final { return m_true_global_variable_ref; }

  IMeshMaterialVariable* toMeshMaterialVariable() final { return this; }


 private:


  VariableRefType* m_true_global_variable_ref = nullptr;

};


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


} // End namespace Arcane::Materials


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


#endif

MaterialsGlobal.h

Arcane::Accelerator::RunQueue
Execution queue for an accelerator.
Definition arccore/src/common/arccore/common/accelerator/RunQueue.h:53

Arcane::Array2VariableT
Variable on a 2D array.
Definition Array2Variable.h:37

Arcane::Array2View
Mutable view for a 2D array.
Definition arccore/src/base/arccore/base/Array2View.h:39

Arcane::Array2View::data
constexpr DataType * data()
Pointer to the allocated memory.
Definition arccore/src/base/arccore/base/Array2View.h:137

Arcane::Array2View::totalNbElement
constexpr Integer totalNbElement() const
Total number of elements.
Definition arccore/src/base/arccore/base/Array2View.h:71

Arcane::Array2
Class representing a classic 2D array.
Definition arccore/src/collections/arccore/collections/Array2.h:44

Arcane::ArrayView
Modifiable view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:96

Arcane::Array
Base class for 1D data vectors.
Definition arccore/src/common/arccore/common/Array.h:44

Arcane::ConstArray2View
View for a constant 2D array.
Definition arccore/src/base/arccore/base/Array2View.h:155

Arcane::ConstArrayView
Constant view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:550

Arcane::IArray2DataT
Interface of a bi-dimensional array data item of type T.
Definition IData.h:374

Arcane::IArrayDataT
Interface of a 1D array data item of type T.
Definition IData.h:300

Arcane::IData
Interface of a data item.
Definition IData.h:34

Arcane::ISerializer
Serializer interface.
Definition arccore/src/serialize/arccore/serialize/ISerializer.h:59

Arcane::ITraceMng
Trace manager interface.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:175

Arcane::IVariable
Interface of a variable.
Definition IVariable.h:40

Arcane::Materials::AllEnvCellVectorView
View over a list of cells with environment information.
Definition core/materials/MatItemEnumerator.h:75

Arcane::Materials::CopyBetweenPartialAndGlobalArgs
Arguments for methods copying between partial and global values.
Definition IMeshMaterialVariableInternal.h:93

Arcane::Materials::IArrayMeshMaterialVariable
Access interface for CellMaterialVariableArrayRef.
Definition IArrayMeshMaterialVariable.h:37

Arcane::Materials::IMeshComponent
Interface of a component (material or environment) of a mesh.
Definition core/materials/IMeshComponent.h:37

Arcane::Materials::IMeshMaterialVariableComputeFunction
Interface of the functor class for recalculating a variable.
Definition core/materials/IMeshMaterialVariableComputeFunction.h:32

Arcane::Materials::IMeshMaterialVariableInternal
Arcane internal API for 'IMeshMaterialVariable'.
Definition IMeshMaterialVariableInternal.h:165

Arcane::Materials::IMeshMaterialVariable
Interface of a material variable on a mesh.
Definition core/materials/IMeshMaterialVariable.h:48

Arcane::Materials::IMeshMaterial
Interface of a mesh material.
Definition core/materials/IMeshMaterial.h:55

Arcane::Materials::IScalarMeshMaterialVariable
Access interface for CellMaterialVariableScalarRef.
Definition IScalarMeshMaterialVariable.h:37

Arcane::Materials::InitializeWithZeroArgs
Arguments for methods copying between partial and global values.
Definition IMeshMaterialVariableInternal.h:126

Arcane::Materials::ItemMaterialVariableArray::m_host_views
UniqueArray< ContainerViewType > m_host_views
List of views visible only from the host.
Definition MeshMaterialVariable.h:375

Arcane::Materials::ItemMaterialVariableArray::synchronize
ARCANE_MATERIALS_EXPORT void synchronize() override
Synchronizes the variable.
Definition MeshMaterialVariableArray.inst.h:250

Arcane::Materials::ItemMaterialVariableArray::serialize
ARCANE_MATERIALS_EXPORT void serialize(ISerializer *sbuffer, Int32ConstArrayView ids) override
Serializes the variable for local ID entities ids.
Definition MeshMaterialVariableArray.inst.h:165

Arcane::Materials::ItemMaterialVariableArray::dumpValues
ARCANE_MATERIALS_EXPORT void dumpValues(std::ostream &ostr) override
Dumps the variable values to the stream ostr.
Definition MeshMaterialVariableArray.inst.h:142

Arcane::Materials::ItemMaterialVariableBase::syncReferences
ARCANE_MATERIALS_EXPORT void syncReferences() override
Synchronizes references.
Definition ItemMaterialVariableBaseT.H:250

Arcane::Materials::ItemMaterialVariableBase::buildFromManager
ARCANE_MATERIALS_EXPORT void buildFromManager(bool is_continue) override
Builds the variable information. For internal use in Arcane.
Definition ItemMaterialVariableBaseT.H:147

Arcane::Materials::ItemMaterialVariableBase::globalVariable
ARCANE_MATERIALS_EXPORT IVariable * globalVariable() const override
Associated global variable on the mesh.
Definition ItemMaterialVariableBaseT.H:99

Arcane::Materials::ItemMaterialVariableBase< MaterialVariableScalarTraits< DataType > >::m_host_views
UniqueArray< ContainerViewType > m_host_views
Definition MeshMaterialVariable.h:375

Arcane::Materials::ItemMaterialVariableBase< MaterialVariableScalarTraits< DataType > >::m_vars
UniqueArray< PrivatePartType * > m_vars
Definition MeshMaterialVariable.h:371

Arcane::Materials::ItemMaterialVariableBase< MaterialVariableScalarTraits< DataType > >::m_device_views
UniqueArray< ContainerViewType > m_device_views
Definition MeshMaterialVariable.h:373

Arcane::Materials::ItemMaterialVariableBase::fillPartialValuesWithGlobalValues
ARCANE_MATERIALS_EXPORT void fillPartialValuesWithGlobalValues() override
Fills partial values with the value of the associated global cell.
Definition ItemMaterialVariableBaseT.H:502

Arcane::Materials::ItemMaterialVariableBase::_setView
void _setView(Int32 index)
Positions the views from the container.
Definition MeshMaterialVariable.h:385

Arcane::Materials::ItemMaterialVariableBase::fillPartialValuesWithSuperValues
ARCANE_MATERIALS_EXPORT void fillPartialValuesWithSuperValues(Int32 level) override
Fills partial values with the value of the super cell. If level equals LEVEL_MATERIAL,...
Definition ItemMaterialVariableBaseT.H:512

Arcane::Materials::ItemMaterialVariableScalar::m_host_views
UniqueArray< ContainerViewType > m_host_views
List of views visible only from the host.
Definition MeshMaterialVariable.h:375

Arcane::Materials::ItemMaterialVariableScalar::fillPartialValues
ARCANE_MATERIALS_EXPORT void fillPartialValues(const DataType &value)
Fills the partial values with the value value.
Definition MeshMaterialVariableScalar.cc:266

Arcane::Materials::ItemMaterialVariableScalar::synchronize
ARCANE_MATERIALS_EXPORT void synchronize() override
Synchronizes the variable.
Definition MeshMaterialVariableScalar.cc:346

Arcane::Materials::ItemMaterialVariableScalar::fillToArray
ARCANE_MATERIALS_EXPORT void fillToArray(IMeshMaterial *mat, ArrayView< DataType > values)
Fills an array from the variable values for a material.
Definition MeshMaterialVariableScalar.cc:220

Arcane::Materials::ItemMaterialVariableScalar::serialize
ARCANE_MATERIALS_EXPORT void serialize(ISerializer *sbuffer, Int32ConstArrayView ids) override
Serializes the variable for local ID entities ids.
Definition MeshMaterialVariableScalar.cc:702

Arcane::Materials::ItemMaterialVariableScalar::dumpValues
ARCANE_MATERIALS_EXPORT void dumpValues(std::ostream &ostr) override
Dumps the variable values to the stream ostr.
Definition MeshMaterialVariableScalar.cc:687

Arcane::Materials::ItemMaterialVariableScalar::fillFromArray
ARCANE_MATERIALS_EXPORT void fillFromArray(IMeshMaterial *mat, ConstArrayView< DataType > values)
Fills the variable values for a material from an array.
Definition MeshMaterialVariableScalar.cc:163

Arcane::Materials::MatVarIndex
Represents an index on material and environment variables.
Definition core/materials/MatVarIndex.h:40

Arcane::Materials::MatVarIndex::arrayIndex
constexpr __host__ __device__ Int32 arrayIndex() const
Returns the index of the value array in the list of variables.
Definition core/materials/MatVarIndex.h:53

Arcane::Materials::MatVarIndex::valueIndex
constexpr __host__ __device__ Int32 valueIndex() const
Returns the index in the value array.
Definition core/materials/MatVarIndex.h:56

Arcane::Materials::MaterialVariableArrayTraits
Characteristics for an array material variable.
Definition MeshMaterialVariable.h:227

Arcane::Materials::MaterialVariableBuildInfo
Definition core/materials/MaterialVariableBuildInfo.h:31

Arcane::Materials::MaterialVariableScalarTraits
Characteristics for a scalar material variable.
Definition MeshMaterialVariable.h:179

Arcane::Materials::MeshMaterialVariableCommonStaticImpl
Definition MeshMaterialVariable.h:404

Arcane::Materials::MeshMaterialVariableCommonStaticImpl::getReference
static ARCANE_MATERIALS_EXPORT IMeshMaterialVariable * getReference(const MaterialVariableBuildInfo &v, MatVarSpace mvs)
Retrieves or constructs a variable.
Definition ItemMaterialVariableBaseT.H:561

Arcane::Materials::MeshMaterialVariableFactoryRegisterer
Registerer for a material variable factory..
Definition MeshMaterialVariableFactoryRegisterer.h:38

Arcane::Materials::MeshMaterialVariablePrivate
Private section of a material variable.
Definition MeshMaterialVariablePrivate.h:45

Arcane::Materials::MeshMaterialVariableRef
Base class for material variable references.
Definition core/materials/MeshMaterialVariableRef.h:50

Arcane::Materials::MeshMaterialVariableSynchronizerList
Synchronizing a list of material variables.
Definition MeshMaterialVariableSynchronizerList.h:40

Arcane::Materials::MeshMaterialVariable::setUpToDate
void setUpToDate(IMeshMaterial *mat) override
Indicates that the variable has just been updated.
Definition MeshMaterialVariable.cc:375

Arcane::Materials::MeshMaterialVariable::firstReference
MeshMaterialVariableRef * firstReference() const override
Definition MeshMaterialVariable.cc:282

Arcane::Materials::MeshMaterialVariable::incrementReference
void incrementReference()
Definition MeshMaterialVariable.cc:202

Arcane::Materials::MeshMaterialVariable::modifiedTime
Int64 modifiedTime(IMeshMaterial *mat) override
Time when the variable was updated.
Definition MeshMaterialVariable.cc:382

Arcane::Materials::MeshMaterialVariable::removeVariableRef
void removeVariableRef(MeshMaterialVariableRef *var_ref) override
Removes a reference to this variable.
Definition MeshMaterialVariable.cc:238

Arcane::Materials::MeshMaterialVariable::update
void update(IMeshMaterial *mat) override
Recalculates the variable for material mat if necessary.
Definition MeshMaterialVariable.cc:328

Arcane::Materials::MeshMaterialVariable::dependInfos
void dependInfos(Array< VariableDependInfo > &infos, Array< MeshMaterialVariableDependInfo > &mat_infos) override
Dependency information.
Definition MeshMaterialVariable.cc:439

Arcane::Materials::MeshMaterialVariable::addVariableRef
void addVariableRef(MeshMaterialVariableRef *var_ref) override
Adds a reference to this variable.
Definition MeshMaterialVariable.cc:217

Arcane::Materials::MeshMaterialVariable::computeFunction
IMeshMaterialVariableComputeFunction * computeFunction() override
Function used to update the variable.
Definition MeshMaterialVariable.cc:433

Arcane::Materials::MeshMaterialVariable::setKeepOnChange
void setKeepOnChange(bool v) override
Indicates whether the variable value should be kept after a change in the list of materials.
Definition MeshMaterialVariable.cc:310

Arcane::Materials::MeshMaterialVariable::addDepend
void addDepend(IMeshMaterialVariable *var) override
Adds var to the dependency list.
Definition MeshMaterialVariable.cc:389

Arcane::Materials::MeshMaterialVariable::removeDepend
void removeDepend(IMeshMaterialVariable *var) override
Removes var from the dependency list.
Definition MeshMaterialVariable.cc:401

Arcane::Materials::MeshMaterialVariable::materialVariable
IVariable * materialVariable(IMeshMaterial *mat) override
Variable containing the specific values of the material mat.
Definition MeshMaterialVariable.cc:300

Arcane::Materials::MeshMaterialVariable::setComputeFunction
void setComputeFunction(IMeshMaterialVariableComputeFunction *v) override
Sets the variable's recalculation function.
Definition MeshMaterialVariable.cc:427

Arcane::Materials::MeshMaterialVariable::name
String name() const override
Name of the variable.
Definition MeshMaterialVariable.cc:291

Arcane::Materials::MeshMaterialVariable::space
MatVarSpace space() const override
Variable definition space (material+environment or environment only).
Definition MeshMaterialVariable.cc:461

Arcane::Materials::MeshMaterialVariable::_toInt32Indexes
static SmallSpan< const Int32 > _toInt32Indexes(SmallSpan< const MatVarIndex > indexes)
Converts a view of MatVarIndex to a view of Int32.
Definition MeshMaterialVariable.cc:475

Arcane::Materials::MeshMaterialVariable::keepOnChange
bool keepOnChange() const override
Indicates whether the variable value should be kept after a change in the list of materials.
Definition MeshMaterialVariable.cc:319

Arcane::Materials::ResizeVariableIndexerArgs
Arguments for methods copying between partial and global values.
Definition IMeshMaterialVariableInternal.h:148

Arcane::MeshVariableArrayRefT
Array variable on a mesh entity type.
Definition MeshVariableArrayRef.h:118

Arcane::MeshVariableScalarRefT
Scalar variable on a mesh entity type.
Definition MeshVariableScalarRef.h:218

Arcane::Ref
Reference to an instance.
Definition arccore/src/base/arccore/base/Ref.h:325

Arcane::SmallSpan2
View for a 2D array whose size is an 'Int32'.
Definition Span2.h:249

Arcane::SmallSpan
View of an array of elements of type T.
Definition Span.h:805

Arcane::SpanImpl::copy
__host__ __device__ void copy(const U &copy_array)
Copies the array copy_array into the instance.
Definition Span.h:477

Arcane::SpanImpl::fill
__host__ __device__ void fill(T o)
Fills the array with the value o.
Definition Span.h:383

Arcane::Span
View of an array of elements of type T.
Definition Span.h:635

Arcane::String
Unicode character string.
Definition arccore/src/base/arccore/base/String.h:70

Arcane::TraceInfo
Trace information.
Definition arccore/src/base/arccore/base/TraceInfo.h:34

Arcane::UniqueArray2
2D data vector with value semantics (STL style).
Definition arccore/src/collections/arccore/collections/Array2.h:729

Arcane::UniqueArray
1D data vector with value semantics (STL style).
Definition arccore/src/common/arccore/common/Array.h:890

Arcane::VariableArrayT
Implementation of a variable on a 1D array.
Definition VariableArray.h:37

Arcane::VariableBuildInfo
Parameters necessary for building a variable.
Definition VariableBuildInfo.h:44

Arcane::VariableInfo
Information characterizing a variable.
Definition VariableInfo.h:38

Arcane::VariableRefArray2T
Two-dimensional array variable.
Definition VariableRefArray2.h:38

Arcane::VariableRefArrayT
Array variable.
Definition VariableRefArray.h:40

Arcane::VariableRef
Reference to a variable.
Definition VariableRef.h:56

Arcane::Materials
Always enables tracing in Arcane parts concerning materials.
Definition RunCommandMaterialEnumerate.h:34

Arcane::Materials::MeshComponentList
ConstArrayView< IMeshComponent * > MeshComponentList
List of multi-material components of the mesh.
Definition MaterialsCoreGlobal.h:164

Arcane::Materials::MatVarSpace
MatVarSpace
Definition space for a material variable.
Definition MaterialsCoreGlobal.h:220

Arcane::Materials::ARCANE_MATERIALS_EXPORT
class ARCANE_MATERIALS_EXPORT(64) SimdMatVarIndex
SIMD indexer on a component.
Definition ComponentSimd.h:52

Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37

Arcane::dataTypeSize
ARCANE_DATATYPE_EXPORT Integer dataTypeSize(eDataType type)
Size of data type type (which must be different from DT_String).
Definition DataTypes.cc:111

Arcane::ByteArrayView
ArrayView< Byte > ByteArrayView
C equivalent of a 1D array of characters.
Definition UtilsTypes.h:447

Arcane::Int64
std::int64_t Int64
Signed integer type of 64 bits.
Definition ArccoreGlobal.h:235

Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293

Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
C equivalent of a 1D array of 32-bit integers.
Definition UtilsTypes.h:482

Arcane::Real
double Real
Type representing a real number.
Definition ArccoreGlobal.h:275

Arcane::ByteConstArrayView
ConstArrayView< Byte > ByteConstArrayView
C equivalent of a 1D array of characters.
Definition UtilsTypes.h:476

Arcane::asWritableBytes
Impl::SpanTypeFromSize< std::byte, SizeType >::SpanType asWritableBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converts the view into an array of modifiable bytes.
Definition Span.h:1068

Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233