Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
AnyItemVariableArray.h
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/* AnyItemVariableArray.h (C) 2000-2022 */
9/* */
10/* Variable tableau aggrégée de types quelconques. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_ANYITEMS_ANYITEMVARIABLEARRAY_H
13#define ARCANE_ANYITEMS_ANYITEMVARIABLEARRAY_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/Exception.h"
18
19#include "arcane/anyitem/AnyItemGlobal.h"
20#include "arcane/anyitem/AnyItemGroup.h"
21#include "arcane/anyitem/AnyItemLinkFamily.h"
22#include "arcane/VariableTypedef.h"
23
24/*---------------------------------------------------------------------------*/
25/*---------------------------------------------------------------------------*/
26
27namespace Arcane::AnyItem
28{
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
55template<typename DataType>
56class VariableArray : public IFamilyObserver
57{
58public:
59
63 class VariableAdder
64 {
65 public:
66
67 VariableAdder(VariableArray<DataType>& variable, const ItemGroup& group)
68 : m_variable(variable)
69 , m_group(group)
70 , m_used(false) {}
71
72 ~VariableAdder()
73 {
74 ARCANE_ASSERT((m_used == true),("VariableAdder never used"));
75 }
76
78 template<typename K, typename T>
80 {
81 ARCANE_ASSERT((m_used == false),("VariableAdder already used"));
82 m_variable._insertVariable(m_group,v.asArray());
83 m_variable._insertInternalVariable(m_group,v.variable());
84 m_used = true;
85 }
86
88 template<typename K, typename T>
90 {
91 ARCANE_ASSERT((m_used == false),("VariableAdder already used"));
92 m_variable._insertPartialVariable(m_group,v.asArray());
93 m_variable._insertInternalVariable(m_group,v.variable());
94 m_used = true;
95 }
96 private:
97
99 VariableArray<DataType>& m_variable;
100
103
105 bool m_used;
106 };
107
108public:
109
110 VariableArray(const Family& family)
112 , m_values(m_family.groupSize())
113 , m_variables(m_family.groupSize())
114 {
115 // la famille enregistre les variables portées
116 m_family.registerObserver(*this);
117 for(Integer i = 0; i < m_family.groupSize(); ++i)
118 m_variables[i] = NULL;
119 }
120
122 : m_family(v.m_family)
123 , m_values(v.m_values)
125 {
126 // la famille enregistre les variables portées
128 }
129
130 ~VariableArray()
131 {
132 // la famille désenregistre la variable
134 }
135
138 return m_values[item.groupIndex()][item.varIndex()];
139 }
140
143 return m_values[item.groupIndex()][item.varIndex()];
144 }
145
147 inline ArrayView<DataType> operator[](const LinkFamily::LinkData & item) {
148 return m_values[item.groupIndex()][item.varIndex()];
149 }
150
152 inline ConstArrayView<DataType> operator[](const LinkFamily::LinkData & item) const {
153 return m_values[item.groupIndex()][item.varIndex()];
154 }
155
157 inline VariableAdder operator[](const ItemGroup& group)
158 {
159 return VariableAdder(*this,group);
160 }
161
162 template<typename T>
163 inline VariableAdder operator[](const ItemGroupT<T>& group)
164 {
165 return VariableAdder(*this,group);
166 }
167
169 inline const Family& family() const { return m_family; }
170
173 {
174 return m_variables;
175 }
176
179 {
180 return m_values[igrp];
181 }
182
185 {
186 return m_values[igrp];
187 }
188
191 // Si la famille change, on invalide les variables et on retaille
192 m_values.resize(m_family.groupSize());
193 m_variables.resize(m_family.groupSize());
194 for(Integer i = 0; i < m_family.groupSize(); ++i)
195 m_variables[i] = NULL;
196 }
197
200 // Si la famille est agrandie, on retaille simplement
201 const Integer old_size = m_values.size();
202 ARCANE_ASSERT((old_size < m_family.groupSize()),("Old size greater than new size!"));
203 m_values.resize(m_family.groupSize());
204 m_variables.resize(m_family.groupSize());
205 for(Integer i = old_size; i < m_family.groupSize(); ++i)
206 m_variables[i] = NULL;
207 }
208
209private:
210
211 inline void _insertVariable(ItemGroup group, Array2View<DataType> v)
212 {
213 if(m_family.isPartial(group))
214 throw FatalErrorException(String::format("Group '{0}' defined partial",group.name()));
215 m_values[m_family.groupIndex(group)] = v;
216 }
217
218 inline void _insertPartialVariable(ItemGroup group, Array2View<DataType> v)
219 {
220 if(not m_family.isPartial(group))
221 throw FatalErrorException(String::format("Group '{0}' not defined partial",group.name()));
222 m_values[m_family.groupIndex(group)] = v;
223 }
224
225 inline void _insertInternalVariable(ItemGroup group, IVariable* v)
226 {
227 m_variables[m_family.groupIndex(group)] = v;
228 }
229
230private:
231
234
237
240};
241
242/*---------------------------------------------------------------------------*/
243/*---------------------------------------------------------------------------*/
244
245} // End namespace Arcane::AnyItem
246
247/*---------------------------------------------------------------------------*/
248/*---------------------------------------------------------------------------*/
249
250#endif /* ARCANE_ANYITEMS_ANYITEMVARIABLE_H */
Famille AnyItem (pattern flyweight) Aggrégation de groupes pour décrire des variables / variables par...
bool isPartial(const ItemGroup &group) const
retourne vrai si le groupe est associé à une variable partielle
void removeObserver(IFamilyObserver &observer) const
Supprime un observeur.
void registerObserver(IFamilyObserver &observer) const
Enregistre un observeur.
Integer groupIndex(const ItemGroup &group) const
Position du groupe dans la famille.
Enumérateur d'un bloc d'items.
Integer varIndex() const
localId() de l'entité courante.
Integer groupIndex() const
Index dans la AnyItem::Family du groupe en cours.
Outil pour l'ajout de variable à un groupe.
const ItemGroup & m_group
Groupe de la variable.
VariableArray< DataType > & m_variable
Variable AnyItem.
void operator<<(MeshVariableArrayRefT< K, T > &v)
Liaison d'un variable.
void operator<<(MeshPartialVariableArrayRefT< K, T > &v)
Liaison d'une variable partielle.
bool m_used
Indicateur sur l'utilisation du Adder.
Variable tableau aggrégée de types quelconques (pas de variables tableaux) ATTENTION Les variables ar...
Arcane::UniqueArray< Array2View< DataType > > m_values
Conteneur des variables génériques.
const Family m_family
Famille AnyItem des groupes.
ArrayView< DataType > operator[](const LinkFamily::LinkData &item)
Accesseur direct par un élément de LinkFamily (LinkData)
void notifyFamilyIsIncreased()
Notification d'aggrandissement de la famille.
const Family & family() const
Accesseur à la famille.
ArrayView< DataType > operator[](const Group::BlockItemEnumerator &item)
Accesseur direct par un enumerateur AnyItem.
ConstArray2View< DataType > valuesAtGroup(const Integer igrp) const
Doonnées brutes associées à un groupe identifié relativement à sa famille.
Array2View< DataType > valuesAtGroup(const Integer igrp)
Doonnées brutes associées à un groupe identifié relativement à sa famille.
ConstArrayView< DataType > operator[](const Group::BlockItemEnumerator &item) const
Accesseur direct par un enumerateur AnyItem.
ConstArrayView< IVariable * > variables() const
Tableau des variables.
void notifyFamilyIsInvalidate()
Notification d'invalidation de la famille.
VariableAdder operator[](const ItemGroup &group)
Ajout d'une variable pour un groupe.
Arcane::UniqueArray< IVariable * > m_variables
Conteneur des variables.
ConstArrayView< DataType > operator[](const LinkFamily::LinkData &item) const
Accesseur direct par un élément de LinkFamily (LinkData)
Vue modifiable pour un tableau 2D.
Vue modifiable d'un tableau d'un type T.
Vue constante d'un tableau de type T.
Exception lorsqu'une erreur fatale est survenue.
Interface d'observeurs de famille AnyItem.
Référence à un groupe d'un genre donné.
Definition ItemGroup.h:398
Groupe d'entités de maillage.
Definition ItemGroup.h:49
const String & name() const
Nom du groupe.
Definition ItemGroup.h:76
Integer varIndex() const
Identifiant localId de l'item référencé dans sa famille IItemFamily d'origine.
Integer groupIndex() const
Identifiant du groupe auquel est associé l'item référencé par ce LinkData.
Variable scalaire sur un type d'entité du maillage.
Variable tableau sur un type d'entité du maillage.
Vecteur 1D de données avec sémantique par valeur (style STL).
IVariable * variable() const
Variable associée.
Int32 Integer
Type représentant un entier.
void arcaneCallFunctionAndTerminateIfThrow(std::function< void()> function)