Arcane  v3.16.0.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MeshEnvironmentVariableRef.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* MeshMaterialVariableRef.cc (C) 2000-2024 */
9/* */
10/* Référence à une variable sur un matériau du maillage. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
15
16#include "arcane/utils/NotImplementedException.h"
17#include "arcane/utils/TraceInfo.h"
18#include "arcane/utils/NumericTypes.h"
19
20#include "arcane/MeshVariableScalarRef.h"
21#include "arcane/ArcaneException.h"
22
23#include "arcane/core/materials/IMeshMaterialMng.h"
24#include "arcane/core/materials/IMeshMaterial.h"
25#include "arcane/core/materials/MaterialVariableBuildInfo.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33namespace Arcane::Materials
34{
35
36/*---------------------------------------------------------------------------*/
37/*---------------------------------------------------------------------------*/
38
39template<typename DataType> CellEnvironmentVariableScalarRef<DataType>::
40CellEnvironmentVariableScalarRef(const VariableBuildInfo& vb)
42{
43}
44
45/*---------------------------------------------------------------------------*/
46/*---------------------------------------------------------------------------*/
47
48template<typename DataType> CellEnvironmentVariableScalarRef<DataType>::
49CellEnvironmentVariableScalarRef(const MaterialVariableBuildInfo& vb)
50: m_private_part(PrivatePartType::BuilderType::getVariableReference(vb,MatVarSpace::Environment))
51, m_value(nullptr)
52{
53 _init();
54}
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
59template<typename DataType> CellEnvironmentVariableScalarRef<DataType>::
60CellEnvironmentVariableScalarRef(const CellEnvironmentVariableScalarRef<DataType>& rhs)
61: m_private_part(rhs.m_private_part)
62, m_value(nullptr)
63{
64 // Il faut incrémenter manuellement le compteur de référence car normalement
65 // cela est fait dans getReference() mais ici on ne l'appelle pas
66 if (m_private_part)
67 m_private_part->incrementReference();
69 _init();
70}
71
72/*---------------------------------------------------------------------------*/
73/*---------------------------------------------------------------------------*/
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
77
78template<typename DataType> void
80_init()
81{
82 if (m_private_part){
83 this->_setContainerView();
84 _internalInit(m_private_part->toMeshMaterialVariable());
85 }
86}
87
88/*---------------------------------------------------------------------------*/
89/*---------------------------------------------------------------------------*/
90
91template<typename DataType> void
93refersTo(const CellEnvironmentVariableScalarRef<DataType>& rhs)
94{
95 if (rhs.m_private_part==m_private_part)
96 return;
97 if (_isRegistered())
99
100 m_private_part = rhs.m_private_part;
101 m_value = nullptr;
102 m_container_value = {};
103
104 // Il faut incrémenter manuellement le compteur de référence car normalement
105 // cela est fait dans getReference() mais ici on ne l'appelle pas
106 if (m_private_part)
107 m_private_part->incrementReference();
108 _init();
109}
110
111/*---------------------------------------------------------------------------*/
112/*---------------------------------------------------------------------------*/
113
114template<typename DataType> void
117{
118 _setContainerView();
119}
121/*---------------------------------------------------------------------------*/
122/*---------------------------------------------------------------------------*/
123
124template<typename DataType> DataType
126envValue(AllEnvCell c,Int32 env_id) const
127{
129 EnvCell ec = *ienvcell;
130 Int32 eid = ec.environmentId();
131 if (eid==env_id)
132 return this->operator[](ienvcell);
133 }
134 return DataType();
135}
136
137/*---------------------------------------------------------------------------*/
138/*---------------------------------------------------------------------------*/
139/*!
140 * \brief Remplit les valeurs partielles et globales de la variable avec la valeur \a value
141 */
142template<typename DataType> void
144fill(const DataType& value)
145{
146 globalVariable().fill(value);
147 fillPartialValues(value);
148}
149
150/*---------------------------------------------------------------------------*/
151/*---------------------------------------------------------------------------*/
152/*!
153 * \brief Remplit les valeurs partielles de la variable avec la valeur \a value
154 */
155template<typename DataType> void
157fillPartialValues(const DataType& value)
158{
159 m_private_part->fillPartialValues(value);
160}
161
162/*---------------------------------------------------------------------------*/
163/*---------------------------------------------------------------------------*/
164
165/*---------------------------------------------------------------------------*/
166/*---------------------------------------------------------------------------*/
167
168template<typename DataType> MeshVariableScalarRefT<Cell,DataType>&
171{
172 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
173 if (!rt)
174 ARCANE_FATAL("null global variable");
175 return *rt;
176}
177
178/*---------------------------------------------------------------------------*/
179/*---------------------------------------------------------------------------*/
180
181template<typename DataType> const MeshVariableScalarRefT<Cell,DataType>&
184{
185 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
186 if (!rt)
187 ARCANE_FATAL("null global variable");
188 return *rt;
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
194template<typename DataType> void
197{
198 if (m_private_part){
199 m_container_value = m_private_part->_internalFullValuesView();
200 m_value = m_container_value.data();
201 }
202 else{
203 m_container_value = {};
204 m_value = nullptr;
206}
207
208/*---------------------------------------------------------------------------*/
209/*---------------------------------------------------------------------------*/
210
211/*---------------------------------------------------------------------------*/
212/*---------------------------------------------------------------------------*/
213
214// TODO: fusionner avec la version scalaire
215template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
218{
219}
220
221/*---------------------------------------------------------------------------*/
222/*---------------------------------------------------------------------------*/
223
224// TODO: fusionner avec la version scalaire
227: m_private_part(PrivatePartType::BuilderType::getVariableReference(vb,MatVarSpace::Environment))
228, m_value(nullptr)
229{
230 _init();
231}
232
233/*---------------------------------------------------------------------------*/
234/*---------------------------------------------------------------------------*/
235
236// TODO: fusionner avec la version scalaire
237template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
239: m_private_part(rhs.m_private_part)
240, m_value(nullptr)
241{
242 // Il faut incrémenter manuellement le compteur de référence car normalement
243 // cela est fait dans getReference() mais ici on ne l'appelle pas
244 if (m_private_part)
245 m_private_part->incrementReference();
246
247 _init();
248}
249
250/*---------------------------------------------------------------------------*/
251/*---------------------------------------------------------------------------*/
252
253// TODO: fusionner avec la version scalaire
254template<typename DataType> void
256_init()
257{
258 if (m_private_part){
259 _setContainerView();
260 _internalInit(m_private_part->toMeshMaterialVariable());
261 }
262}
263
264/*---------------------------------------------------------------------------*/
265/*---------------------------------------------------------------------------*/
266
267// TODO: fusionner avec la version scalaire
268template<typename DataType> void
270refersTo(const CellEnvironmentVariableArrayRef<DataType>& rhs)
271{
272 if (rhs.m_private_part==m_private_part)
273 return;
274 if (_isRegistered())
276
277 m_private_part = rhs.m_private_part;
278 m_value = nullptr;
279 m_container_value = {};
280
281 // Il faut incrémenter manuellement le compteur de référence car normalement
282 // cela est fait dans getReference() mais ici on ne l'appelle pas
283 if (m_private_part)
284 m_private_part->incrementReference();
285 _init();
286}
287
288/*---------------------------------------------------------------------------*/
289/*---------------------------------------------------------------------------*/
290
291// TODO: fusionner avec la version scalaire
292template<typename DataType> void
295{
296 _setContainerView();
297}
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
302template<typename DataType> MeshVariableArrayRefT<Cell,DataType>&
305{
306 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
307 if (!rt)
308 ARCANE_FATAL("null global variable");
309 return *rt;
310}
311
312/*---------------------------------------------------------------------------*/
313/*---------------------------------------------------------------------------*/
314
315template<typename DataType> const MeshVariableArrayRefT<Cell,DataType>&
317globalVariable() const
318{
319 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
320 if (!rt)
321 ARCANE_FATAL("null global variable");
322 return *rt;
323}
324
325/*---------------------------------------------------------------------------*/
326/*---------------------------------------------------------------------------*/
327
328template<typename DataType> void
330resize(Integer dim2_size)
331{
332 m_private_part->resize(dim2_size);
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338template<typename DataType> void
341{
342 if (m_private_part){
343 m_container_value = m_private_part->_internalFullValuesView();
344 m_value = m_container_value.data();
345 }
346 else{
347 m_container_value = {};
348 m_value = nullptr;
349 }
350}
351
352/*---------------------------------------------------------------------------*/
353/*---------------------------------------------------------------------------*/
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
357
358#define ARCANE_INSTANTIATE_MAT(type) \
359 template class ARCANE_TEMPLATE_EXPORT CellEnvironmentVariableScalarRef<type>;\
360 template class ARCANE_TEMPLATE_EXPORT CellEnvironmentVariableArrayRef<type>
361
362ARCANE_INSTANTIATE_MAT(Byte);
363ARCANE_INSTANTIATE_MAT(Int8);
364ARCANE_INSTANTIATE_MAT(Int16);
365ARCANE_INSTANTIATE_MAT(Int32);
366ARCANE_INSTANTIATE_MAT(Int64);
367ARCANE_INSTANTIATE_MAT(BFloat16);
368ARCANE_INSTANTIATE_MAT(Float16);
369ARCANE_INSTANTIATE_MAT(Float32);
370ARCANE_INSTANTIATE_MAT(Real);
371ARCANE_INSTANTIATE_MAT(Real2);
372ARCANE_INSTANTIATE_MAT(Real3);
373ARCANE_INSTANTIATE_MAT(Real2x2);
374ARCANE_INSTANTIATE_MAT(Real3x3);
375
376/*---------------------------------------------------------------------------*/
377/*---------------------------------------------------------------------------*/
378
379} // End Arcane::Materials
380
381/*---------------------------------------------------------------------------*/
382/*---------------------------------------------------------------------------*/
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Maille arcane avec info matériaux et milieux.
Variable tableau sur les mailles d'un matériau du maillage. Pour l'instant, cette classe n'est instan...
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
CellEnvironmentVariableArrayRef()=delete
Constructeur vide (interdit)
void resize(Integer dim2_size)
Redimensionne le nombre d'éléments du tableau.
Variable scalaire sur les mailles d'un milieu du maillage.
DataType envValue(AllEnvCell c, Int32 env_id) const
Valeur de la variable pour le milieu d'index env_id de la maille ou 0 si absent de la maille.
void fillPartialValues(const DataType &value)
Remplit les valeurs partielles de la variable avec la valeur value.
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
CellEnvironmentVariableScalarRef()=delete
Constructeur vide (interdit)
void fill(const DataType &value)
Remplit les valeurs partielles et globales de la variable avec la valeur value.
Maille arcane d'un milieu.
__host__ __device__ Int32 environmentId() const
Identifiant du milieu.
void unregisterVariable()
Supprime l'enregistrement de la variable (interne)
Variable tableau sur un type d'entité du maillage.
Variable scalaire sur un type d'entité du maillage.
Paramètres nécessaires à la construction d'une variable.
#define ENUMERATE_CELL_ENVCELL(iname, all_env_cell)
Macro pour itérer sur tous les milieux d'une maille.
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.
std::int8_t Int8
Type entier signé sur 8 bits.
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
std::int16_t Int16
Type entier signé sur 16 bits.
double Real
Type représentant un réel.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
float Float32
Type flottant IEEE-753 simple précision.
std::int32_t Int32
Type entier signé sur 32 bits.