Arcane  v3.15.0.0
Documentation développeur
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
14#include "arcane/core/materials/MeshEnvironmentVariableRef.h"
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)
41: CellEnvironmentVariableScalarRef(MaterialVariableBuildInfo(nullptr,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}
55
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();
68
69 _init();
70}
71
72/*---------------------------------------------------------------------------*/
73/*---------------------------------------------------------------------------*/
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
77
78template<typename DataType> void
79CellEnvironmentVariableScalarRef<DataType>::
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
92CellEnvironmentVariableScalarRef<DataType>::
93refersTo(const CellEnvironmentVariableScalarRef<DataType>& rhs)
94{
95 if (rhs.m_private_part==m_private_part)
96 return;
97 if (_isRegistered())
98 unregisterVariable();
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
120
121/*---------------------------------------------------------------------------*/
122/*---------------------------------------------------------------------------*/
123
124template<typename DataType> DataType
125CellEnvironmentVariableScalarRef<DataType>::
126envValue(AllEnvCell c,Int32 env_id) const
127{
128 ENUMERATE_CELL_ENVCELL(ienvcell,c){
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/*---------------------------------------------------------------------------*/
142template<typename DataType> void
143CellEnvironmentVariableScalarRef<DataType>::
144fill(const DataType& value)
145{
146 globalVariable().fill(value);
147 fillPartialValues(value);
148}
149
150/*---------------------------------------------------------------------------*/
151/*---------------------------------------------------------------------------*/
155template<typename DataType> void
156CellEnvironmentVariableScalarRef<DataType>::
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>&
169CellEnvironmentVariableScalarRef<DataType>::
170globalVariable()
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>&
182CellEnvironmentVariableScalarRef<DataType>::
183globalVariable() const
184{
185 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
186 if (!rt)
187 ARCANE_FATAL("null global variable");
188 return *rt;
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194template<typename DataType> void
195CellEnvironmentVariableScalarRef<DataType>::
196_setContainerView()
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;
205 }
206}
207
208/*---------------------------------------------------------------------------*/
209/*---------------------------------------------------------------------------*/
210
211/*---------------------------------------------------------------------------*/
212/*---------------------------------------------------------------------------*/
213
214// TODO: fusionner avec la version scalaire
215template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
216CellEnvironmentVariableArrayRef(const VariableBuildInfo& vb)
217: CellEnvironmentVariableArrayRef(MaterialVariableBuildInfo(nullptr,vb))
218{
219}
220
221/*---------------------------------------------------------------------------*/
222/*---------------------------------------------------------------------------*/
223
224// TODO: fusionner avec la version scalaire
225template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
226CellEnvironmentVariableArrayRef(const MaterialVariableBuildInfo& vb)
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>::
238CellEnvironmentVariableArrayRef(const CellEnvironmentVariableArrayRef<DataType>& rhs)
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
255CellEnvironmentVariableArrayRef<DataType>::
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
269CellEnvironmentVariableArrayRef<DataType>::
270refersTo(const CellEnvironmentVariableArrayRef<DataType>& rhs)
271{
272 if (rhs.m_private_part==m_private_part)
273 return;
274 if (_isRegistered())
275 unregisterVariable();
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
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
302template<typename DataType> MeshVariableArrayRefT<Cell,DataType>&
303CellEnvironmentVariableArrayRef<DataType>::
304globalVariable()
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>&
316CellEnvironmentVariableArrayRef<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
329CellEnvironmentVariableArrayRef<DataType>::
330resize(Integer dim2_size)
331{
332 m_private_part->resize(dim2_size);
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338template<typename DataType> void
339CellEnvironmentVariableArrayRef<DataType>::
340_setContainerView()
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/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:815
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:149
Arcane::Materials::AllEnvCell
Maille arcane avec info matériaux et milieux.
Definition core/materials/MatItem.h:166
Arcane::Materials::CellEnvironmentVariableArrayRef
Variable tableau sur les mailles d'un matériau du maillage. Pour l'instant, cette classe n'est instan...
Definition core/materials/MeshEnvironmentVariableRef.h:157
Arcane::Materials::CellEnvironmentVariableArrayRef::globalVariable
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
Definition MeshEnvironmentVariableRef.cc:304
Arcane::Materials::CellEnvironmentVariableArrayRef::refersTo
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshEnvironmentVariableRef.cc:270
Arcane::Materials::CellEnvironmentVariableArrayRef::CellEnvironmentVariableArrayRef
CellEnvironmentVariableArrayRef()=delete
Constructeur vide (interdit)
Arcane::Materials::CellEnvironmentVariableArrayRef::resize
void resize(Integer dim2_size)
Redimensionne le nombre d'éléments du tableau.
Definition MeshEnvironmentVariableRef.cc:330
Arcane::Materials::CellEnvironmentVariableScalarRef
Variable scalaire sur les mailles d'un milieu du maillage.
Definition core/materials/MeshEnvironmentVariableRef.h:42
Arcane::Materials::CellEnvironmentVariableScalarRef::envValue
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.
Definition MeshEnvironmentVariableRef.cc:126
Arcane::Materials::CellEnvironmentVariableScalarRef::fillPartialValues
void fillPartialValues(const DataType &value)
Remplit les valeurs partielles de la variable avec la valeur value.
Definition MeshEnvironmentVariableRef.cc:157
Arcane::Materials::CellEnvironmentVariableScalarRef::globalVariable
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
Definition MeshEnvironmentVariableRef.cc:170
Arcane::Materials::CellEnvironmentVariableScalarRef::refersTo
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshEnvironmentVariableRef.cc:93
Arcane::Materials::CellEnvironmentVariableScalarRef::CellEnvironmentVariableScalarRef
CellEnvironmentVariableScalarRef()=delete
Constructeur vide (interdit)
Arcane::Materials::CellEnvironmentVariableScalarRef::fill
void fill(const DataType &value)
Remplit les valeurs partielles et globales de la variable avec la valeur value.
Definition MeshEnvironmentVariableRef.cc:144
Arcane::Materials::EnvCell
Maille arcane d'un milieu.
Definition core/materials/MatItem.h:106
ENUMERATE_CELL_ENVCELL
#define ENUMERATE_CELL_ENVCELL(iname, all_env_cell)
Macro pour itérer sur tous les milieux d'une maille.
Definition core/materials/MatItemEnumerator.h:658
Arcane::Materials
Active toujours les traces dans les parties Arcane concernant les matériaux.
Definition RunCommandMaterialEnumerate.h:33
Arcane::Materials::MatVarSpace
MatVarSpace
Espace de définition d'une variable matériau.
Definition MaterialsCoreGlobal.h:195
Arcane::Materials::MatVarSpace::Environment
@ Environment
Variable ayant des valeurs uniquement sur les milieux.
Arcane::Float16
Arccore::Float16 Float16
Type 'Float16' (binary16)
Definition ArcaneGlobal.h:265
Arcane::Int8
Arccore::Int8 Int8
Type représentant un entier sur 8 bits.
Definition ArcaneGlobal.h:271
Arcane::BFloat16
Arccore::BFloat16 BFloat16
Type 'Brain Float16'.
Definition ArcaneGlobal.h:262
Arcane::Float32
float Float32
Type flottant IEEE-753 simple précision (binary32)
Definition ArcaneGlobal.h:268
Arcane::Byte
unsigned char Byte
Type d'un octet.
Definition UtilsTypes.h:148