Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
MeshVariableArrayRefT.H
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/* MeshVariableArrayRefT.H (C) 2000-2024 */
9/* */
10/* Variable vectorielle du maillage. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/MeshVariableArrayRef.h"
15
16#include "arcane/utils/ValueConvert.h"
17#include "arcane/utils/FatalErrorException.h"
18
19#include "arcane/core/ItemGroup.h"
20#include "arcane/core/VariableDataTypeTraits.h"
21#include "arcane/core/VariableTypeInfo.h"
22#include "arcane/core/VariableBuildInfo.h"
23#include "arcane/core/VariableInfo.h"
24#include "arcane/core/VariableFactoryRegisterer.h"
25#include "arcane/core/internal/IDataInternal.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30namespace Arcane
31{
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36template<typename DataType> VariableTypeInfo
37ItemVariableArrayRefT<DataType>::
38_internalVariableTypeInfo(eItemKind ik)
39{
40 eDataType dt = VariableDataTypeTraitsT<DataType>::type();
41 return VariableTypeInfo(ik,dt,2,0,false);
42}
43
44/*---------------------------------------------------------------------------*/
45/*---------------------------------------------------------------------------*/
46
47template<typename DataType> VariableInfo
48ItemVariableArrayRefT<DataType>::
49_internalVariableInfo(const VariableBuildInfo& vbi,eItemKind ik)
50{
51 VariableTypeInfo vti = _internalVariableTypeInfo(ik);
52 DataStorageTypeInfo sti = vti._internalDefaultDataStorage();
53 return VariableInfo(vbi.name(),vbi.itemFamilyName(),vbi.itemGroupName(),vbi.meshName(),vti,sti);
54}
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
59template<class DataType>
60ItemVariableArrayRefT<DataType>::
61ItemVariableArrayRefT(const VariableBuildInfo& vb,eItemKind ik)
62: PrivateVariableArrayT<DataType>(vb,_internalVariableInfo(vb,ik))
63{
64 if (!vb.isNull()) {
65 this->_internalInit();
66 if (this->m_private_part->isPartial())
67 ARCANE_FATAL("Can not assign a partial variable to a full variable");
68 }
69}
70
71/*---------------------------------------------------------------------------*/
72/*---------------------------------------------------------------------------*/
73
74template<class DataType> ItemVariableArrayRefT<DataType>::
75ItemVariableArrayRefT(IVariable* var)
76: PrivateVariableArrayT<DataType>(var)
77{
78 this->_internalInit();
79 if (this->m_private_part->isPartial())
80 ARCANE_FATAL("Can not assign a partial variable to a full variable");
81}
82
83/*---------------------------------------------------------------------------*/
84/*---------------------------------------------------------------------------*/
85
86template<class DataType> ItemVariableArrayRefT<DataType>::
87ItemVariableArrayRefT(const ItemVariableArrayRefT<DataType>& rhs)
88: PrivateVariableArrayT<DataType>(rhs)
89{
90 if (this->m_private_part)
91 this->updateFromInternal();
92}
93
94/*---------------------------------------------------------------------------*/
95/*---------------------------------------------------------------------------*/
96
97template <class DataType> ItemVariableArrayRefT<DataType>&
98ItemVariableArrayRefT<DataType>::
99operator=(const ItemVariableArrayRefT<DataType>& rhs)
100{
101 if (this != &rhs) {
102 BaseClass::operator=(rhs);
103 if (this->m_private_part) {
104 this->m_private_part = rhs.m_private_part;
105 this->updateFromInternal();
106 }
107 }
108 return (*this);
109}
110
111/*---------------------------------------------------------------------------*/
112/*---------------------------------------------------------------------------*/
113
114/*---------------------------------------------------------------------------*/
115/*---------------------------------------------------------------------------*/
116
117template<class ItemType,class DataType> VariableFactoryRegisterer
118MeshVariableArrayRefT<ItemType,DataType>::
119m_auto_registerer(_autoCreate,_internalVariableTypeInfo());
120
121/*---------------------------------------------------------------------------*/
122/*---------------------------------------------------------------------------*/
123
124template<typename ItemType,typename DataType> VariableTypeInfo
125MeshVariableArrayRefT<ItemType,DataType>::
126_internalVariableTypeInfo()
127{
128 eItemKind ik = ItemTraitsT<ItemType>::kind();
129 eDataType dt = VariableDataTypeTraitsT<DataType>::type();
130 return VariableTypeInfo(ik,dt,2,0,false);
131}
132
133/*---------------------------------------------------------------------------*/
134/*---------------------------------------------------------------------------*/
135
136template<typename ItemType,typename DataType> VariableInfo
137MeshVariableArrayRefT<ItemType,DataType>::
138_internalVariableInfo(const VariableBuildInfo& vbi)
139{
140 VariableTypeInfo vti = _internalVariableTypeInfo();
141 DataStorageTypeInfo sti = vti._internalDefaultDataStorage();
142 return VariableInfo(vbi.name(),vbi.itemFamilyName(),vbi.itemGroupName(),vbi.meshName(),vti,sti);
143}
144
145/*---------------------------------------------------------------------------*/
146/*---------------------------------------------------------------------------*/
147
148template<class ItemType,class DataType> VariableRef*
149MeshVariableArrayRefT<ItemType,DataType>::
150_autoCreate(const VariableBuildInfo& vb)
151
152{
153 return new ThatClass(vb);
154}
155
156/*---------------------------------------------------------------------------*/
157/*---------------------------------------------------------------------------*/
158
159template<class ItemType,class DataType>
160MeshVariableArrayRefT<ItemType,DataType>::
161MeshVariableArrayRefT(const VariableBuildInfo& vb)
162: ItemVariableArrayRefT<DataType>(vb,ItemTraitsT<ItemType>::kind())
163{
164 // Normalement, c'est à cette classe de faire l'initilisation mais
165 // comme cette classe est juste un wrapper autour de ItemVariableArrayRefT
166 // et ne fait rien d'autre, on laisse l'initialisation à la classe de base,
167 // ce qui permet de fabriquer de manière générique une variable sur
168 // une entité du maillage à partir de son genre.
169}
170
171/*---------------------------------------------------------------------------*/
172/*---------------------------------------------------------------------------*/
173
174template<class ItemType,class DataType>
175MeshVariableArrayRefT<ItemType,DataType>::
176MeshVariableArrayRefT(IVariable* var)
177: ItemVariableArrayRefT<DataType>(var)
178{
179 // Normalement, c'est à cette classe de faire l'initilisation mais
180 // comme cette classe est juste un wrapper autour de ItemVariableArrayRefT
181 // et ne fait rien d'autre, on laisse l'initialisation à la classe de base,
182 // ce qui permet de fabriquer de manière générique une variable sur
183 // une entité du maillage à partir de son genre.
184}
185
186/*---------------------------------------------------------------------------*/
187/*---------------------------------------------------------------------------*/
188
189template<class ItemType,class DataType>
190MeshVariableArrayRefT<ItemType,DataType>::
191MeshVariableArrayRefT(const MeshVariableArrayRefT<ItemType,DataType>& rhs)
192: ItemVariableArrayRefT<DataType>(rhs)
193{
194 // Normalement, c'est à cette classe de faire l'initilisation mais
195 // comme cette classe est juste un wrapper autour de ItemVariableArrayRefT
196 // et ne fait rien d'autre, on laisse l'initialisation à la classe de base,
197 // ce qui permet de fabriquer de manière générique une variable sur
198 // une entité du maillage à partir de son genre.
199}
200
201/*---------------------------------------------------------------------------*/
202/*---------------------------------------------------------------------------*/
203
204template<class ItemType,class DataType>
205void
211
212/*---------------------------------------------------------------------------*/
213/*---------------------------------------------------------------------------*/
214
215/*---------------------------------------------------------------------------*/
216/*---------------------------------------------------------------------------*/
217
218template<class ItemType,class DataType>
219typename Arcane::MeshVariableArrayRefT<ItemType, DataType>::GroupType
220MeshVariableArrayRefT<ItemType, DataType>::
221itemGroup() const
222{
223 return GroupType(this->m_private_part->itemGroup());
224}
225
226/*---------------------------------------------------------------------------*/
227/*---------------------------------------------------------------------------*/
228
229template<class DataType>
230void ItemVariableArrayRefT<DataType>::
231fill(const DataType& v)
232{
233 this->fill(v,this->itemGroup());
234}
235
236/*---------------------------------------------------------------------------*/
237/*---------------------------------------------------------------------------*/
238
239template<class DataType>
240void ItemVariableArrayRefT<DataType>::
241fill(const DataType& value,const ItemGroup& group)
242{
243 ENUMERATE_ITEM(iitem,group){
244 operator[](iitem).fill(value);
245 }
246}
247
248/*---------------------------------------------------------------------------*/
249/*---------------------------------------------------------------------------*/
250
251template<typename DataType>
252void ItemVariableArrayRefT<DataType>::
253copy(const ItemVariableArrayRefT<DataType>& v)
254{
255 this->copy(v,this->itemGroup());
256}
257
258/*---------------------------------------------------------------------------*/
259/*---------------------------------------------------------------------------*/
260
261template<typename DataType>
262void ItemVariableArrayRefT<DataType>::
263copy(const ItemVariableArrayRefT<DataType>& v,const ItemGroup& group)
264{
265 ENUMERATE_ITEM(iitem,group){
266 operator[](iitem).copy(v[iitem]);
267 }
268}
269
270/*---------------------------------------------------------------------------*/
271/*---------------------------------------------------------------------------*/
272
273template<typename DataTypeT> void
274ItemVariableArrayRefT<DataTypeT>::
275copy(const ItemVariableArrayRefT<DataTypeT>& v,RunQueue* queue)
276{
277 if (!queue){
278 copy(v);
279 return;
280 }
281 impl::copyContiguousData(this->m_private_part->data(), v.m_private_part->data(), *queue);
282}
283
284/*---------------------------------------------------------------------------*/
285/*---------------------------------------------------------------------------*/
286
287template<typename DataTypeT> void
288ItemVariableArrayRefT<DataTypeT>::
289fill(const DataTypeT& v,RunQueue* queue)
290{
291 if (!queue){
292 fill(v);
293 return;
294 }
295 impl::fillContiguousData(this->m_private_part->data(), v, *queue);
296}
297
298/*---------------------------------------------------------------------------*/
299/*---------------------------------------------------------------------------*/
308template<class ItemType,class DataTypeT> void
309MeshVariableArrayRefT<ItemType,DataTypeT>::
310swapValues(MeshVariableArrayRefT<ItemType,DataType>& rhs)
311{
312 this->m_private_part->swapValues(*(rhs.m_private_part));
313}
314
315/*---------------------------------------------------------------------------*/
316/*---------------------------------------------------------------------------*/
317
318} // End namespace Arcane
319
320/*---------------------------------------------------------------------------*/
321/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:764
ENUMERATE_ITEM
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
Definition ItemEnumerator.h:413
Arcane::Accelerator::RunQueue
File d'exécution pour un accélérateur.
Definition core/RunQueue.h:52
Arcane::Array2VariableT::data
IData * data() override
Données associées à la variable.
Definition Array2Variable.h:76
Arcane::DataStorageTypeInfo
Informations de type pour un conteneur de données.
Definition DataStorageTypeInfo.h:33
Arcane::IVariable
Interface d'une variable.
Definition IVariable.h:56
Arcane::ItemGroup
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Arcane::ItemTraitsT
Caractéristiques des éléments du maillage.
Definition ItemTypes.h:621
Arcane::ItemTraitsT::kind
static eItemKind kind()
Genre de l'entité
Definition ItemTypes.h:624
Arcane::ItemVariableArrayRefT
Variable tableau sur un type d'entité du maillage.
Definition MeshVariableArrayRef.h:36
Arcane::ItemVariableArrayRefT::copy
void copy(const ItemVariableArrayRefT< DataType > &v)
Copie les valeurs de v dans cette variable.
Definition MeshVariableArrayRefT.H:253
Arcane::ItemVariableArrayRefT::ItemVariableArrayRefT
ItemVariableArrayRefT(const VariableBuildInfo &b, eItemKind ik)
Construit une référence à la variable spécifiée dans vb.
Definition MeshVariableArrayRefT.H:61
Arcane::ItemVariableArrayRefT::operator[]
ConstArrayType operator[](ItemLocalId item) const
Valeur non modifiable de l'entité item.
Definition MeshVariableArrayRef.h:71
Arcane::ItemVariableArrayRefT::operator=
ItemVariableArrayRefT< DataType > & operator=(const ItemVariableArrayRefT< DataType > &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshVariableArrayRefT.H:99
Arcane::ItemVariableArrayRefT::fill
void fill(const DataType &value)
Remplit la variable avec la valeur value.
Definition MeshVariableArrayRefT.H:231
Arcane::MeshVariableArrayRefT
Variable tableau sur un type d'entité du maillage.
Definition MeshVariableArrayRef.h:116
Arcane::MeshVariableArrayRefT::itemGroup
GroupType itemGroup() const
Groupe associé à la grandeur.
Definition MeshVariableArrayRefT.H:221
Arcane::MeshVariableArrayRefT::swapValues
void swapValues(MeshVariableArrayRefT< ItemType, DataType > &rhs)
Échange les valeurs de la variable rhs avec celles de l'instance.
Definition MeshVariableArrayRefT.H:310
Arcane::MeshVariableArrayRefT::refersTo
void refersTo(const MeshVariableArrayRefT< ItemType, DataType > &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshVariableArrayRefT.H:207
Arcane::VariableBuildInfo
Paramètres nécessaires à la construction d'une variable.
Definition VariableBuildInfo.h:43
Arcane::VariableFactoryRegisterer
Enregistreur d'une fabrique de variables.
Definition VariableFactoryRegisterer.h:41
Arcane::VariableInfo
Infos caractérisant une variable.
Definition VariableInfo.h:37
Arcane::VariableRef
Référence à une variable.
Definition VariableRef.h:56
Arcane::VariableTypeInfo
Informations caractérisant le type d'une variable.
Definition VariableTypeInfo.h:35
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::eItemKind
eItemKind
Genre d'entité de maillage.
Definition ArcaneTypes.h:168
Arcane::eDataType
eDataType
Type d'une donnée.
Definition DataTypes.h:39