core/materials/MeshMaterialVariableRef.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshMaterialVariableRef.h                                   (C) 2000-2025 */
/*                                                                           */
/* Référence à une variable sur un matériau du maillage.                     */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_MATERIALS_MESHMATERIALVARIABLEREF_H
#define ARCANE_MATERIALS_MESHMATERIALVARIABLEREF_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#include "arcane/utils/NotImplementedException.h"
#include "arcane/utils/Array2View.h"
 
#include "arcane/core/Item.h"
#include "arcane/core/VariableRef.h"
 
#include "arcane/core/materials/IMeshMaterialVariable.h"
#include "arcane/core/materials/MatItemEnumerator.h"
#include "arcane/core/materials/MeshMaterialVariableComputeFunction.h"
#include "arcane/core/materials/IScalarMeshMaterialVariable.h"
#include "arcane/core/materials/IArrayMeshMaterialVariable.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Materials
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT MeshMaterialVariableRef
{
 public:
  class Enumerator
  {
   public:
 
    explicit Enumerator(const IMeshMaterialVariable* vp)
    : m_vref(vp->firstReference())
    {
    }
    void operator++()
    {
      m_vref = m_vref->nextReference();
    }
    MeshMaterialVariableRef* operator*() const
    {
      return m_vref;
    }
    bool hasNext() const
    {
      return m_vref;
    }
 
   private:
 
    MeshMaterialVariableRef* m_vref = nullptr;
  };
 
 public:
 
  MeshMaterialVariableRef();
  virtual ~MeshMaterialVariableRef();
 
 public:

  MeshMaterialVariableRef* previousReference();

  MeshMaterialVariableRef* nextReference();

  void setPreviousReference(MeshMaterialVariableRef* v);

  void setNextReference(MeshMaterialVariableRef* v);

  void registerVariable();

  void unregisterVariable();
 
  virtual void updateFromInternal() =0;
  
  IMeshMaterialVariable* materialVariable() const { return m_material_variable; }

  void synchronize();

  void synchronize(MeshMaterialVariableSynchronizerList& sync_list);

  MatVarSpace space() const { return m_material_variable->space(); }

  void fillPartialValuesWithSuperValues(Int32 level)
  {
    m_material_variable->fillPartialValuesWithSuperValues(level);
  }
 
 public:
 
  // Fonctions issues de VariableRef. A terme, il faudra que la variable
  // materiau dérive de la variable classique.
  String name() const;
  void setUpToDate();
  bool isUsed() const;
  void update();
  void addDependCurrentTime(const VariableRef& var);
  void addDependCurrentTime(const VariableRef& var,const TraceInfo& tinfo);
  void addDependCurrentTime(const MeshMaterialVariableRef& var);
  void addDependPreviousTime(const MeshMaterialVariableRef& var);
  void removeDepend(const MeshMaterialVariableRef& var);
  template<typename ClassType> void
  setComputeFunction(ClassType* instance,void (ClassType::*func)())
  { m_global_variable->setComputeFunction(new VariableComputeFunction(instance,func)); }


  void setUpToDate(IMeshMaterial*);
  void update(IMeshMaterial*);
  void addMaterialDepend(const VariableRef& var);
  void addMaterialDepend(const VariableRef& var,const TraceInfo& tinfo);
  void addMaterialDepend(const MeshMaterialVariableRef& var);
  void addMaterialDepend(const MeshMaterialVariableRef& var,const TraceInfo& tinfo);
  template<typename ClassType> void
  setMaterialComputeFunction(ClassType* instance,void (ClassType::*func)(IMeshMaterial*))
  { m_material_variable->setComputeFunction(new MeshMaterialVariableComputeFunction(instance,func)); }
 
 protected:
  
  void _internalInit(IMeshMaterialVariable* mat_variable);
  bool _isRegistered() const { return m_is_registered; }
 
 private:

  IMeshMaterialVariable* m_material_variable;

  MeshMaterialVariableRef* m_previous_reference;

  MeshMaterialVariableRef* m_next_reference;

  IVariable* m_global_variable;
 
  bool m_is_registered;
 
 private:
  void _checkValid() const
  {
#ifdef ARCANE_CHECK
    if (!m_material_variable)
      _throwInvalid();
#endif
  }
  void _throwInvalid() const;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType_>
class CellMaterialVariableScalarRef
: public MeshMaterialVariableRef
{
 public:
 
  using DataType = DataType_;
  using PrivatePartType = IScalarMeshMaterialVariable<Cell, DataType>;
  using ItemType = Cell;
  using GlobalVariableRefType = MeshVariableScalarRefT<ItemType, DataType>;
  using ThatClass = CellMaterialVariableScalarRef<DataType>;
 
 public:
 
  explicit ARCANE_CORE_EXPORT CellMaterialVariableScalarRef(const VariableBuildInfo& vb);
  explicit ARCANE_CORE_EXPORT CellMaterialVariableScalarRef(const MaterialVariableBuildInfo& vb);
  ARCANE_CORE_EXPORT CellMaterialVariableScalarRef(const ThatClass& rhs);
 
 public:

  ARCANE_CORE_EXPORT ThatClass& operator=(const ThatClass& rhs) = delete;
  CellMaterialVariableScalarRef() = delete;
 
 public:

  ARCANE_CORE_EXPORT virtual void refersTo(const ThatClass& rhs);

  ARCANE_CORE_EXPORT void updateFromInternal() override;
 
 protected:
 
  DataType operator[](MatVarIndex mvi) const
  {
    return m_value[mvi.arrayIndex()][mvi.valueIndex()];
  }
  DataType& operator[](MatVarIndex mvi)
  {
    return m_value[mvi.arrayIndex()][mvi.valueIndex()];
  }
 
 public:

  DataType operator[](ComponentItemLocalId mc) const
  {
    return this->operator[](mc.localId());
  }

  DataType& operator[](ComponentItemLocalId mc)
  {
    return this->operator[](mc.localId());
  }

  DataType operator[](CellComponentCellEnumerator mc) const
  {
    return this->operator[](mc._varIndex());
  }

  DataType& operator[](CellComponentCellEnumerator mc)
  {
    return this->operator[](mc._varIndex());
  }

  DataType operator[](CellLocalId c) const
  {
    return m_value[0][c.localId()];
  }

  DataType& operator[](CellLocalId c)
  {
    return m_value[0][c.localId()];
  }

  DataType operator[](PureMatVarIndex mvi) const
  {
    return m_value[0][mvi.valueIndex()];
  }

  DataType& operator[](PureMatVarIndex mvi)
  {
    return m_value[0][mvi.valueIndex()];
  }

  ARCANE_CORE_EXPORT DataType matValue(AllEnvCell c,Int32 mat_id) const;

  ARCANE_CORE_EXPORT DataType envValue(AllEnvCell c,Int32 env_id) const;
 
 public:
  
  ARCANE_CORE_EXPORT void fillFromArray(IMeshMaterial* mat,ConstArrayView<DataType> values);
  ARCANE_CORE_EXPORT void fillFromArray(IMeshMaterial* mat,ConstArrayView<DataType> values,Int32ConstArrayView indexes);
  ARCANE_CORE_EXPORT void fillToArray(IMeshMaterial* mat,ArrayView<DataType> values);
  ARCANE_CORE_EXPORT void fillToArray(IMeshMaterial* mat,ArrayView<DataType> values,Int32ConstArrayView indexes);
  ARCANE_CORE_EXPORT void fillToArray(IMeshMaterial* mat,Array<DataType>& values);
  ARCANE_CORE_EXPORT void fillToArray(IMeshMaterial* mat,Array<DataType>& values,Int32ConstArrayView indexes);
  ARCANE_CORE_EXPORT void fill(const DataType& value);
  ARCANE_CORE_EXPORT void fillPartialValues(const DataType& value);
 
 public:

  ARCANE_CORE_EXPORT GlobalVariableRefType& globalVariable();
  ARCANE_CORE_EXPORT const GlobalVariableRefType& globalVariable() const;
 
 private:
 
  PrivatePartType* m_private_part = nullptr;
  ArrayView<DataType>* m_value = nullptr;
  ArrayView<ArrayView<DataType>> m_container_value;
 
 private:
 
  void _init();
  void _setContainerView();
 
 public:
 
  // TODO: Temporaire. a supprimer.
  ArrayView<DataType>* _internalValue() const { return m_value; }
 
 public:
 
#ifdef ARCANE_DOTNET
  // Uniquement pour le wrapper C#
  // TODO: a terme utiliser 'm_container_view' à la place
  void* _internalValueAsPointerOfPointer() { return reinterpret_cast<void*>(&m_value); }
#endif
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType_>
class CellMaterialVariableArrayRef
: public MeshMaterialVariableRef
{
 public:
 
  using DataType = DataType_;
  using PrivatePartType = IArrayMeshMaterialVariable<Cell, DataType>;
  using ItemType = Cell;
  using GlobalVariableRefType = MeshVariableArrayRefT<ItemType, DataType>;
  using ThatClass = CellMaterialVariableArrayRef<DataType>;
 
 public:
 
  explicit ARCANE_CORE_EXPORT CellMaterialVariableArrayRef(const VariableBuildInfo& vb);
  explicit ARCANE_CORE_EXPORT CellMaterialVariableArrayRef(const MaterialVariableBuildInfo& vb);
  ARCANE_CORE_EXPORT CellMaterialVariableArrayRef(const ThatClass& rhs);
 
 public:

  ARCANE_CORE_EXPORT ThatClass& operator=(const ThatClass& rhs) = delete;
  CellMaterialVariableArrayRef() = delete;
 
 public:

  ARCANE_CORE_EXPORT virtual void refersTo(const ThatClass& rhs);

  ARCANE_CORE_EXPORT void updateFromInternal() override;
 
 public:

  ARCANE_CORE_EXPORT GlobalVariableRefType& globalVariable();
  ARCANE_CORE_EXPORT const GlobalVariableRefType& globalVariable() const;
 
 public:

  ARCANE_CORE_EXPORT void resize(Integer dim2_size);
 
 protected:
 
  ConstArrayView<DataType> operator[](MatVarIndex mvi) const
  {
    return m_value[mvi.arrayIndex()][mvi.valueIndex()];
  }
  ArrayView<DataType> operator[](MatVarIndex mvi)
  {
    return m_value[mvi.arrayIndex()][mvi.valueIndex()];
  }
 
 public:

  ConstArrayView<DataType> operator[](ComponentItemLocalId mc) const
  {
    return this->operator[](mc.localId());
  }

  ArrayView<DataType> operator[](ComponentItemLocalId mc)
  {
    return this->operator[](mc.localId());
  }

  ConstArrayView<DataType> operator[](CellLocalId c) const
  {
    return m_value[0][c.localId()];
  }

  ArrayView<DataType> operator[](CellLocalId c)
  {
    return m_value[0][c.localId()];
  }

  ConstArrayView<DataType> operator[](PureMatVarIndex mvi) const
  {
    return m_value[0][mvi.valueIndex()];
  }

  ArrayView<DataType> operator[](PureMatVarIndex mvi)
  {
    return m_value[0][mvi.valueIndex()];
  }
 
 private:
 
  PrivatePartType* m_private_part = nullptr;
  Array2View<DataType>* m_value = nullptr;
  ArrayView<Array2View<DataType>> m_container_value;
 
 private:
 
  void _init();
  void _setContainerView();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef CellMaterialVariableScalarRef<Byte> MaterialVariableCellByte;
typedef CellMaterialVariableScalarRef<Real> MaterialVariableCellReal;
typedef CellMaterialVariableScalarRef<Int16> MaterialVariableCellInt16;
typedef CellMaterialVariableScalarRef<Int32> MaterialVariableCellInt32;
typedef CellMaterialVariableScalarRef<Int64> MaterialVariableCellInt64;
typedef CellMaterialVariableScalarRef<Real2> MaterialVariableCellReal2;
typedef CellMaterialVariableScalarRef<Real3> MaterialVariableCellReal3;
typedef CellMaterialVariableScalarRef<Real2x2> MaterialVariableCellReal2x2;
typedef CellMaterialVariableScalarRef<Real3x3> MaterialVariableCellReal3x3;
 
#ifdef ARCANE_64BIT
typedef MaterialVariableCellInt64 MaterialVariableCellInteger;
#else
typedef MaterialVariableCellInt32 MaterialVariableCellInteger;
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef CellMaterialVariableArrayRef<Byte> MaterialVariableCellArrayByte;
typedef CellMaterialVariableArrayRef<Real> MaterialVariableCellArrayReal;
typedef CellMaterialVariableArrayRef<Int16> MaterialVariableCellArrayInt16;
typedef CellMaterialVariableArrayRef<Int32> MaterialVariableCellArrayInt32;
typedef CellMaterialVariableArrayRef<Int64> MaterialVariableCellArrayInt64;
typedef CellMaterialVariableArrayRef<Real2> MaterialVariableCellArrayReal2;
typedef CellMaterialVariableArrayRef<Real3> MaterialVariableCellArrayReal3;
typedef CellMaterialVariableArrayRef<Real2x2> MaterialVariableCellArrayReal2x2;
typedef CellMaterialVariableArrayRef<Real3x3> MaterialVariableCellArrayReal3x3;
 
#ifdef ARCANE_64BIT
typedef MaterialVariableCellArrayInt64 MaterialVariableCellArrayInteger;
#else
typedef MaterialVariableCellArrayInt32 MaterialVariableCellArrayInteger;
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Materials
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif