Arcane  v3.14.10.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-2022 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-2022 */
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/Real2.h"
19#include "arcane/utils/Real3.h"
20#include "arcane/utils/Real2x2.h"
21#include "arcane/utils/Real3x3.h"
22
23#include "arcane/MeshVariableScalarRef.h"
24#include "arcane/ArcaneException.h"
25
26#include "arcane/core/materials/IMeshMaterialMng.h"
27#include "arcane/core/materials/IMeshMaterial.h"
28#include "arcane/core/materials/MaterialVariableBuildInfo.h"
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36namespace Arcane::Materials
37{
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42template<typename DataType> CellEnvironmentVariableScalarRef<DataType>::
43CellEnvironmentVariableScalarRef(const VariableBuildInfo& vb)
44: CellEnvironmentVariableScalarRef(MaterialVariableBuildInfo(nullptr,vb))
45{
46}
47
48/*---------------------------------------------------------------------------*/
49/*---------------------------------------------------------------------------*/
50
51template<typename DataType> CellEnvironmentVariableScalarRef<DataType>::
52CellEnvironmentVariableScalarRef(const MaterialVariableBuildInfo& vb)
53: m_private_part(PrivatePartType::BuilderType::getVariableReference(vb,MatVarSpace::Environment))
54, m_value(nullptr)
55{
56 _init();
57}
58
59/*---------------------------------------------------------------------------*/
60/*---------------------------------------------------------------------------*/
61
62template<typename DataType> CellEnvironmentVariableScalarRef<DataType>::
63CellEnvironmentVariableScalarRef(const CellEnvironmentVariableScalarRef<DataType>& rhs)
64: m_private_part(rhs.m_private_part)
65, m_value(nullptr)
66{
67 // Il faut incrémenter manuellement le compteur de référence car normalement
68 // cela est fait dans getReference() mais ici on ne l'appelle pas
69 if (m_private_part)
70 m_private_part->incrementReference();
71
72 _init();
73}
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
77
78/*---------------------------------------------------------------------------*/
79/*---------------------------------------------------------------------------*/
80
81template<typename DataType> void
82CellEnvironmentVariableScalarRef<DataType>::
83_init()
84{
85 if (m_private_part){
86 this->_setContainerView();
87 _internalInit(m_private_part->toMeshMaterialVariable());
88 }
89}
90
91/*---------------------------------------------------------------------------*/
92/*---------------------------------------------------------------------------*/
93
94template<typename DataType> void
95CellEnvironmentVariableScalarRef<DataType>::
96refersTo(const CellEnvironmentVariableScalarRef<DataType>& rhs)
97{
98 if (rhs.m_private_part==m_private_part)
99 return;
100 if (_isRegistered())
101 unregisterVariable();
102
103 m_private_part = rhs.m_private_part;
104 m_value = nullptr;
105 m_container_value = {};
106
107 // Il faut incrémenter manuellement le compteur de référence car normalement
108 // cela est fait dans getReference() mais ici on ne l'appelle pas
109 if (m_private_part)
110 m_private_part->incrementReference();
111 _init();
112}
113
114/*---------------------------------------------------------------------------*/
115/*---------------------------------------------------------------------------*/
116
117template<typename DataType> void
123
124/*---------------------------------------------------------------------------*/
125/*---------------------------------------------------------------------------*/
126
127template<typename DataType> DataType
128CellEnvironmentVariableScalarRef<DataType>::
129envValue(AllEnvCell c,Int32 env_id) const
130{
131 ENUMERATE_CELL_ENVCELL(ienvcell,c){
132 EnvCell ec = *ienvcell;
133 Int32 eid = ec.environmentId();
134 if (eid==env_id)
135 return this->operator[](ienvcell);
136 }
137 return DataType();
138}
139
140/*---------------------------------------------------------------------------*/
141/*---------------------------------------------------------------------------*/
145template<typename DataType> void
146CellEnvironmentVariableScalarRef<DataType>::
147fill(const DataType& value)
148{
149 globalVariable().fill(value);
150 fillPartialValues(value);
151}
152
153/*---------------------------------------------------------------------------*/
154/*---------------------------------------------------------------------------*/
158template<typename DataType> void
159CellEnvironmentVariableScalarRef<DataType>::
160fillPartialValues(const DataType& value)
161{
162 m_private_part->fillPartialValues(value);
163}
164
165/*---------------------------------------------------------------------------*/
166/*---------------------------------------------------------------------------*/
167
168/*---------------------------------------------------------------------------*/
169/*---------------------------------------------------------------------------*/
170
171template<typename DataType> MeshVariableScalarRefT<Cell,DataType>&
172CellEnvironmentVariableScalarRef<DataType>::
173globalVariable()
174{
175 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
176 if (!rt)
177 ARCANE_FATAL("null global variable");
178 return *rt;
179}
180
181/*---------------------------------------------------------------------------*/
182/*---------------------------------------------------------------------------*/
183
184template<typename DataType> const MeshVariableScalarRefT<Cell,DataType>&
185CellEnvironmentVariableScalarRef<DataType>::
186globalVariable() const
187{
188 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
189 if (!rt)
190 ARCANE_FATAL("null global variable");
191 return *rt;
192}
193
194/*---------------------------------------------------------------------------*/
195/*---------------------------------------------------------------------------*/
196
197template<typename DataType> void
198CellEnvironmentVariableScalarRef<DataType>::
199_setContainerView()
200{
201 if (m_private_part){
202 m_container_value = m_private_part->_internalFullValuesView();
203 m_value = m_container_value.data();
204 }
205 else{
206 m_container_value = {};
207 m_value = nullptr;
208 }
209}
210
211/*---------------------------------------------------------------------------*/
212/*---------------------------------------------------------------------------*/
213
214/*---------------------------------------------------------------------------*/
215/*---------------------------------------------------------------------------*/
216
217// TODO: fusionner avec la version scalaire
218template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
219CellEnvironmentVariableArrayRef(const VariableBuildInfo& vb)
220: CellEnvironmentVariableArrayRef(MaterialVariableBuildInfo(nullptr,vb))
221{
222}
223
224/*---------------------------------------------------------------------------*/
225/*---------------------------------------------------------------------------*/
226
227// TODO: fusionner avec la version scalaire
228template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
229CellEnvironmentVariableArrayRef(const MaterialVariableBuildInfo& vb)
230: m_private_part(PrivatePartType::BuilderType::getVariableReference(vb,MatVarSpace::Environment))
231, m_value(nullptr)
232{
233 _init();
234}
235
236/*---------------------------------------------------------------------------*/
237/*---------------------------------------------------------------------------*/
238
239// TODO: fusionner avec la version scalaire
240template<typename DataType> CellEnvironmentVariableArrayRef<DataType>::
241CellEnvironmentVariableArrayRef(const CellEnvironmentVariableArrayRef<DataType>& rhs)
242: m_private_part(rhs.m_private_part)
243, m_value(nullptr)
244{
245 // Il faut incrémenter manuellement le compteur de référence car normalement
246 // cela est fait dans getReference() mais ici on ne l'appelle pas
247 if (m_private_part)
248 m_private_part->incrementReference();
249
250 _init();
251}
252
253/*---------------------------------------------------------------------------*/
254/*---------------------------------------------------------------------------*/
255
256// TODO: fusionner avec la version scalaire
257template<typename DataType> void
258CellEnvironmentVariableArrayRef<DataType>::
259_init()
260{
261 if (m_private_part){
262 _setContainerView();
263 _internalInit(m_private_part->toMeshMaterialVariable());
264 }
265}
266
267/*---------------------------------------------------------------------------*/
268/*---------------------------------------------------------------------------*/
269
270// TODO: fusionner avec la version scalaire
271template<typename DataType> void
272CellEnvironmentVariableArrayRef<DataType>::
273refersTo(const CellEnvironmentVariableArrayRef<DataType>& rhs)
274{
275 if (rhs.m_private_part==m_private_part)
276 return;
277 if (_isRegistered())
278 unregisterVariable();
279
280 m_private_part = rhs.m_private_part;
281 m_value = nullptr;
282 m_container_value = {};
283
284 // Il faut incrémenter manuellement le compteur de référence car normalement
285 // cela est fait dans getReference() mais ici on ne l'appelle pas
286 if (m_private_part)
287 m_private_part->incrementReference();
288 _init();
289}
290
291/*---------------------------------------------------------------------------*/
292/*---------------------------------------------------------------------------*/
293
294// TODO: fusionner avec la version scalaire
295template<typename DataType> void
301
302/*---------------------------------------------------------------------------*/
303/*---------------------------------------------------------------------------*/
304
305template<typename DataType> MeshVariableArrayRefT<Cell,DataType>&
306CellEnvironmentVariableArrayRef<DataType>::
307globalVariable()
308{
309 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
310 if (!rt)
311 ARCANE_FATAL("null global variable");
312 return *rt;
313}
314
315/*---------------------------------------------------------------------------*/
316/*---------------------------------------------------------------------------*/
317
318template<typename DataType> const MeshVariableArrayRefT<Cell,DataType>&
319CellEnvironmentVariableArrayRef<DataType>::
320globalVariable() const
321{
322 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
323 if (!rt)
324 ARCANE_FATAL("null global variable");
325 return *rt;
326}
327
328/*---------------------------------------------------------------------------*/
329/*---------------------------------------------------------------------------*/
330
331template<typename DataType> void
332CellEnvironmentVariableArrayRef<DataType>::
333resize(Integer dim2_size)
334{
335 m_private_part->resize(dim2_size);
336}
337
338/*---------------------------------------------------------------------------*/
339/*---------------------------------------------------------------------------*/
340
341template<typename DataType> void
342CellEnvironmentVariableArrayRef<DataType>::
343_setContainerView()
344{
345 if (m_private_part){
346 m_container_value = m_private_part->_internalFullValuesView();
347 m_value = m_container_value.data();
348 }
349 else{
350 m_container_value = {};
351 m_value = nullptr;
352 }
353}
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
357
358/*---------------------------------------------------------------------------*/
359/*---------------------------------------------------------------------------*/
360
361#define ARCANE_INSTANTIATE_MAT(type) \
362 template class ARCANE_TEMPLATE_EXPORT CellEnvironmentVariableScalarRef<type>;\
363 template class ARCANE_TEMPLATE_EXPORT CellEnvironmentVariableArrayRef<type>
364
365ARCANE_INSTANTIATE_MAT(Byte);
366ARCANE_INSTANTIATE_MAT(Int16);
367ARCANE_INSTANTIATE_MAT(Int32);
368ARCANE_INSTANTIATE_MAT(Int64);
369ARCANE_INSTANTIATE_MAT(Real);
370ARCANE_INSTANTIATE_MAT(Real2);
371ARCANE_INSTANTIATE_MAT(Real3);
372ARCANE_INSTANTIATE_MAT(Real2x2);
373ARCANE_INSTANTIATE_MAT(Real3x3);
374
375/*---------------------------------------------------------------------------*/
376/*---------------------------------------------------------------------------*/
377
378} // End Arcane::Materials
379
380/*---------------------------------------------------------------------------*/
381/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:809
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
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:307
Arcane::Materials::CellEnvironmentVariableArrayRef::refersTo
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshEnvironmentVariableRef.cc:273
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:333
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:129
Arcane::Materials::CellEnvironmentVariableScalarRef::fillPartialValues
void fillPartialValues(const DataType &value)
Remplit les valeurs partielles de la variable avec la valeur value.
Definition MeshEnvironmentVariableRef.cc:160
Arcane::Materials::CellEnvironmentVariableScalarRef::globalVariable
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
Definition MeshEnvironmentVariableRef.cc:173
Arcane::Materials::CellEnvironmentVariableScalarRef::refersTo
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshEnvironmentVariableRef.cc:96
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:147
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 ItemCompatibility.h:27
Arcane::Materials::MatVarSpace
MatVarSpace
Espace de définition d'une variable matériau.
Definition MaterialsCoreGlobal.h:172
Arcane::Materials::MatVarSpace::Environment
@ Environment
Variable ayant des valeurs uniquement sur les milieux.
Arcane::Byte
unsigned char Byte
Type d'un octet.
Definition UtilsTypes.h:142