14#include "arcane/utils/NotImplementedException.h"
15#include "arcane/utils/NumericTypes.h"
16#include "arcane/utils/ITraceMng.h"
17#include "arcane/utils/CheckedConvert.h"
19#include "arcane/materials/MeshMaterialVariable.h"
20#include "arcane/materials/MaterialVariableBuildInfo.h"
21#include "arcane/materials/MeshMaterialVariableSynchronizerList.h"
22#include "arcane/materials/MatItemEnumerator.h"
23#include "arcane/materials/ComponentItemVectorView.h"
24#include "arcane/materials/internal/MeshMaterialVariablePrivate.h"
26#include "arcane/core/Array2Variable.h"
27#include "arcane/core/VariableRefArray2.h"
28#include "arcane/core/MeshVariable.h"
29#include "arcane/core/ISerializer.h"
30#include "arcane/core/internal/IVariableInternal.h"
32#include "arcane/materials/ItemMaterialVariableBaseT.H"
34#include "arcane/datatype/DataTypeTraits.h"
35#include "arcane/datatype/DataStorageBuildInfo.h"
46template<
typename DataType>
void
48copyTo(SmallSpan2<const DataType> input, SmallSpan<const Int32> input_indexes,
49 SmallSpan2<DataType> output, SmallSpan<const Int32> output_indexes,
50 const RunQueue& queue)
53 Integer nb_value = input_indexes.size();
54 Integer dim2_size = input.dim2Size();
60 auto xo = output[output_indexes[i]];
61 auto xi = input[ input_indexes[i] ];
62 for(
Integer j=0; j<dim2_size; ++j )
70template<
typename DataType>
void
74 ContainerType& values = data->_internal()->_internalDeprecatedValue();
75 Integer dim2_size = values.dim2Size();
79 container.resize(dim1_size,dim2_size);
85template<
typename DataType>
void
92 Int32 nb_add =
static_cast<Int32>(dim1_size * reserve_ratio);
93 var->_internalApi()->resize(VariableResizeArgs(dim1_size, nb_add,
true));
99template<
typename DataType>
void
102 Array<ContainerViewType>& cviews)
107 ConstArrayView<Array2View<DataType>> views = cviews;
110 auto* true_data =
dynamic_cast<ValueDataType*
>(data);
112 ContainerType& values = true_data->_internal()->_internalDeprecatedValue();
115 Integer dim2_size = views[0].dim2Size();
116 Integer current_dim1_size = values.dim1Size();
118 values.resizeNoInit(current_dim1_size+added_dim1_size,dim2_size);
119 ConstArrayView<MatVarIndex> mvi_indexes = component_view._matvarIndexes();
121 for(
Integer i=0, n=mvi_indexes.size(); i<n; ++i ){
123 values[i+current_dim1_size].copy(views[mvi.arrayIndex()][mvi.valueIndex()]);
133: BaseClass(v,global_var,global_var_ref,mvs)
140template<
typename DataType>
void
141ItemMaterialVariableArray<DataType>::
142dumpValues(std::ostream& ostr)
151template<
typename DataType>
void
152ItemMaterialVariableArray<DataType>::
163template<
typename DataType>
void
164ItemMaterialVariableArray<DataType>::
168 IItemFamily* family = m_global_variable->itemFamily();
176 Int32 dim2_size = m_global_variable->valueView().dim2Size();
178 switch(sbuf->
mode()){
179 case ISerializer::ModeReserve:
187 nb_val += envcell.nbMaterial();
190 sbuf->
reserve(m_global_variable->fullName());
192 Int64 nb_basic_value = nb_val * nb_count * dim2_size;
201 values.
addRange(value(ienvcell._varIndex()));
204 values.
addRange(value(imatcell._varIndex()));
211 sbuf->
put(m_global_variable->fullName());
221 if (m_global_variable->fullName()!=ref_name)
222 ARCANE_FATAL(
"Bad serialization expected={0} found={1}",m_global_variable->fullName(),ref_name);
224 Int32 nb_basic_value = nb_value * nb_count;
225 basic_values.
resize(nb_basic_value);
233 setValue(ienvcell._varIndex(),data_values[index]);
237 setValue(imatcell._varIndex(),data_values[index]);
254template<
typename DataType>
void
255ItemMaterialVariableArray<DataType>::
266template<
typename DataType>
void
276template<
typename DataType>
void
280 for( PrivatePartType* pvar : m_vars ){
282 Integer dim1_size = pvar->valueView().dim1Size();
283 pvar->directResize(dim1_size,dim2_size);
293 this->syncReferences();
299template<
typename DataType> Int32
300ItemMaterialVariableArray<DataType>::
303 Int32 dim2_size = m_vars[0]->valueView().dim2Size();
304 return (Int32)
sizeof(DataType) * dim2_size;
310template<
typename DataType>
void
311ItemMaterialVariableArray<DataType>::
312_copyToBufferLegacy(SmallSpan<const MatVarIndex> matvar_indexes,Span<std::byte> bytes)
const
315 Integer dim2_size = m_vars[0]->valueView().dim2Size();
319 const Int32 value_size = CheckedConvert::toInt32(bytes.size() / one_data_size);
320 Array2View<DataType> values(
reinterpret_cast<DataType*
>(bytes.data()),value_size,dim2_size);
321 for( Integer z=0; z<value_size; ++z ){
322 values[z].copy(value(matvar_indexes[z]));
329template<
typename DataType>
void
330ItemMaterialVariableArray<DataType>::
331copyToBuffer(ConstArrayView<MatVarIndex> matvar_indexes,ByteArrayView bytes)
const
333 auto* ptr =
reinterpret_cast<std::byte*
>(bytes.data());
334 return _copyToBufferLegacy(matvar_indexes,{ptr,bytes.size()});
340template<
typename DataType>
void
341ItemMaterialVariableArray<DataType>::
342_copyFromBufferLegacy(SmallSpan<const MatVarIndex> matvar_indexes,Span<const std::byte> bytes)
345 Integer dim2_size = m_vars[0]->valueView().dim2Size();
349 const Integer value_size = CheckedConvert::toInt32(bytes.size() / one_data_size);
350 ConstArray2View<DataType> values(
reinterpret_cast<const DataType*
>(bytes.data()),value_size,dim2_size);
351 for( Integer z=0; z<value_size; ++z ){
352 setValue(matvar_indexes[z],values[z]);
359template<
typename DataType>
void
360ItemMaterialVariableArray<DataType>::
361copyFromBuffer(ConstArrayView<MatVarIndex> matvar_indexes,ByteConstArrayView bytes)
363 auto* ptr =
reinterpret_cast<const std::byte*
>(bytes.data());
364 return _copyFromBufferLegacy(matvar_indexes,{ptr,bytes.size()});
373template<
typename ItemType,
typename DataType>
374MeshMaterialVariableArray<ItemType,DataType>::
375MeshMaterialVariableArray(
const MaterialVariableBuildInfo& v,PrivatePartType* global_var,
376 VariableRefType* global_var_ref,MatVarSpace mvs)
377: ItemMaterialVariableArray<DataType>(v,global_var,global_var_ref,mvs)
378, m_true_global_variable_ref(global_var_ref)
385#define ARCANE_INSTANTIATE_MAT(type) \
386 template class ItemMaterialVariableBase<MaterialVariableArrayTraits<type>>; \
387 template class ItemMaterialVariableArray<type>; \
388 template class MeshMaterialVariableArray<Cell, type>; \
389 template class MeshMaterialVariableCommonStaticImpl<MeshMaterialVariableArray<Cell, type>>
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
#define RUNCOMMAND_LOOP1(iter_name, x1,...)
Boucle sur accélérateur avec arguments supplémentaires pour les réductions.
Int64 largeSize() const
Nombre d'éléments du vecteur (en 64 bits)
void addRange(ConstReferenceType val, Int64 n)
Ajoute n élément de valeur val à la fin du tableau.
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
const T * data() const
Accès à la racine du tableau hors toute protection.
Interface d'une famille d'entités.
virtual ItemVectorView view(Int32ConstArrayView local_ids)=0
Vue sur les entités.
Interface d'un sérialiseur.
void reserveInt64(Int64 n)
Réserve pour n Int64.
virtual void reserve(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n objets de type dt.
@ ModePut
Le sérialiseur attend des reserve()
@ ModeGet
Le sérialiseur attend des get()
virtual Int64 getInt64()=0
Récupère une taille.
virtual void put(Span< const Real > values)=0
Ajoute le tableau values.
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
virtual eMode mode() const =0
Mode de fonctionnement actuel.
virtual void getSpan(Span< Real > values)
Récupère le tableau values.
virtual void get(ArrayView< Real > values)=0
Récupère le tableau values.
virtual void reserveSpan(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n valeurs de dt.
virtual void putInt64(Int64 value)=0
Ajoute l'entier value.
Vue sur un vecteur d'entités.
Vue sur un vecteur sur les entités d'un composant.
Integer nbItem() const
Nombre d'entités dans la vue.
Maille arcane d'un milieu.
Interface d'un composant (matériau ou milieu) d'un maillage.
Interface du gestionnaire des matériaux et des milieux d'un maillage.
Représente un index sur les variables matériaux et milieux.
Caractéristiques pour une variable matériaux tableau.
Synchronisation d'une liste de variables matériaux.
void apply()
Effectue la synchronisation.
void add(MeshMaterialVariable *var)
Ajoute la variable var à la liste des variables à synchroniser.
MatVarSpace space() const override
Espace de définition de la variable (matériau+milieu ou milieu uniquement)
Vue pour un tableau 2D dont la taille est un 'Int32'.
Vue d'un tableau d'éléments de type T.
Chaîne de caractères unicode.
Vecteur 1D de données avec sémantique par valeur (style STL).
RunCommand makeCommand(const RunQueue &run_queue)
Créé une commande associée à la file run_queue.
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
Active toujours les traces dans les parties Arcane concernant les matériaux.
MatVarSpace
Espace de définition d'une variable matériau.
@ Environment
Variable ayant des valeurs uniquement sur les milieux.
ARCANE_DATATYPE_EXPORT Integer dataTypeSize(eDataType type)
Taille du type de donnée type (qui doit être différent de DT_String)
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
eBasicDataType
Type d'une donnée de base.
double Real
Type représentant un réel.
std::int32_t Int32
Type entier signé sur 32 bits.