Arcane  v3.16.0.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MeshMaterialVariableRef.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/utils/NotImplementedException.h"
15#include "arcane/utils/TraceInfo.h"
16#include "arcane/utils/NumericTypes.h"
17
18#include "arcane/core/MeshVariableScalarRef.h"
19#include "arcane/core/VariableBuildInfo.h"
20#include "arcane/core/ArcaneException.h"
21
22#include "arcane/core/materials/IMeshMaterialMng.h"
23#include "arcane/core/materials/IMeshMaterial.h"
24#include "arcane/core/materials/MaterialVariableBuildInfo.h"
25#include "arcane/core/materials/MeshMaterialVariableRef.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30namespace Arcane::Materials
31{
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36MeshMaterialVariableRef::
37MeshMaterialVariableRef()
38: m_material_variable(nullptr)
39, m_previous_reference(nullptr)
40, m_next_reference(nullptr)
41, m_global_variable(nullptr)
42, m_is_registered(false)
43{
44}
45
46/*---------------------------------------------------------------------------*/
47/*---------------------------------------------------------------------------*/
48
49MeshMaterialVariableRef::
50~MeshMaterialVariableRef()
51{
52 if (m_is_registered)
53 unregisterVariable();
54}
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
59void MeshMaterialVariableRef::
60unregisterVariable()
61{
62 _checkValid();
63 m_material_variable->removeVariableRef(this);
64 m_is_registered = false;
65}
66
67/*---------------------------------------------------------------------------*/
68/*---------------------------------------------------------------------------*/
69
70void MeshMaterialVariableRef::
71registerVariable()
72{
73 _checkValid();
74 m_material_variable->addVariableRef(this);
75 m_is_registered = true;
76}
77
78/*---------------------------------------------------------------------------*/
79/*---------------------------------------------------------------------------*/
80
81void MeshMaterialVariableRef::
82_internalInit(IMeshMaterialVariable* mat_variable)
83{
84 m_material_variable = mat_variable;
85 m_global_variable = mat_variable->globalVariable();
86 registerVariable();
87 updateFromInternal();
88}
89
90/*---------------------------------------------------------------------------*/
91/*---------------------------------------------------------------------------*/
92
93MeshMaterialVariableRef* MeshMaterialVariableRef::
94previousReference()
95{
96 return m_previous_reference;
97}
98
99/*---------------------------------------------------------------------------*/
100/*---------------------------------------------------------------------------*/
101
102MeshMaterialVariableRef* MeshMaterialVariableRef::
103nextReference()
104{
105 return m_next_reference;
106}
107
108/*---------------------------------------------------------------------------*/
109/*---------------------------------------------------------------------------*/
110
111void MeshMaterialVariableRef::
112setPreviousReference(MeshMaterialVariableRef* v)
113{
114 m_previous_reference = v;
115}
116
117/*---------------------------------------------------------------------------*/
118/*---------------------------------------------------------------------------*/
119
120void MeshMaterialVariableRef::
121setNextReference(MeshMaterialVariableRef* v)
122{
123 m_next_reference = v;
124}
125
126/*---------------------------------------------------------------------------*/
127/*---------------------------------------------------------------------------*/
128
129void MeshMaterialVariableRef::
130_throwInvalid() const
131{
132 ARCANE_THROW(InternalErrorException,"Trying to use uninitialized variable reference");
133}
134
135/*---------------------------------------------------------------------------*/
136/*---------------------------------------------------------------------------*/
137
138void MeshMaterialVariableRef::
139synchronize()
140{
141 _checkValid();
142 m_material_variable->synchronize();
143}
144
145/*---------------------------------------------------------------------------*/
146/*---------------------------------------------------------------------------*/
147
148void MeshMaterialVariableRef::
149synchronize(MeshMaterialVariableSynchronizerList& sync_list)
150{
151 _checkValid();
152 m_material_variable->synchronize(sync_list);
153}
154
155/*---------------------------------------------------------------------------*/
156/*---------------------------------------------------------------------------*/
157
158String MeshMaterialVariableRef::
159name() const
160{
161 return m_global_variable->name();
162}
163void MeshMaterialVariableRef::
164setUpToDate()
165{
166 m_global_variable->setUpToDate();
167}
168bool MeshMaterialVariableRef::
169isUsed() const
170{
171 return m_global_variable->isUsed();
172}
173void MeshMaterialVariableRef::
174update()
175{
176 m_global_variable->update();
177}
178
179void MeshMaterialVariableRef::
180addDependCurrentTime(const VariableRef& var)
181{
182 m_global_variable->addDepend(var.variable(),IVariable::DPT_CurrentTime);
183}
184void MeshMaterialVariableRef::
185addDependCurrentTime(const VariableRef& var,const TraceInfo& tinfo)
186{
187 m_global_variable->addDepend(var.variable(),IVariable::DPT_CurrentTime,tinfo);
188}
189
190void MeshMaterialVariableRef::
191addDependCurrentTime(const MeshMaterialVariableRef& var)
192{
193 m_global_variable->addDepend(var.m_global_variable,IVariable::DPT_CurrentTime);
194}
195
196void MeshMaterialVariableRef::
197addDependPreviousTime(const MeshMaterialVariableRef& var)
198{
199 m_global_variable->addDepend(var.m_global_variable,IVariable::DPT_PreviousTime);
200}
201
202void MeshMaterialVariableRef::
203removeDepend(const MeshMaterialVariableRef& var)
204{
205 m_global_variable->removeDepend(var.m_global_variable);
206}
207
208/*---------------------------------------------------------------------------*/
209/*---------------------------------------------------------------------------*/
210
211void MeshMaterialVariableRef::
212setUpToDate(IMeshMaterial* mat)
213{
214 m_material_variable->setUpToDate(mat);
215}
216
217void MeshMaterialVariableRef::
218update(IMeshMaterial* mat)
219{
220 m_material_variable->update(mat);
221}
222
223void MeshMaterialVariableRef::
224addMaterialDepend(const VariableRef& var)
225{
226 m_material_variable->addDepend(var.variable());
227}
228
229void MeshMaterialVariableRef::
230addMaterialDepend(const VariableRef& var,const TraceInfo& tinfo)
231{
232 m_material_variable->addDepend(var.variable(),tinfo);
233}
234
235void MeshMaterialVariableRef::
236addMaterialDepend(const MeshMaterialVariableRef& var)
237{
238 m_material_variable->addDepend(var.materialVariable());
239}
240
241void MeshMaterialVariableRef::
242addMaterialDepend(const MeshMaterialVariableRef& var,const TraceInfo& tinfo)
243{
244 m_material_variable->addDepend(var.materialVariable(),tinfo);
245}
246
247/*---------------------------------------------------------------------------*/
248/*---------------------------------------------------------------------------*/
249
250/*---------------------------------------------------------------------------*/
251/*---------------------------------------------------------------------------*/
252
253template<typename DataType> CellMaterialVariableScalarRef<DataType>::
254CellMaterialVariableScalarRef(const VariableBuildInfo& vb)
255: CellMaterialVariableScalarRef(MaterialVariableBuildInfo(nullptr,vb))
256{
257}
258
259/*---------------------------------------------------------------------------*/
260/*---------------------------------------------------------------------------*/
261
262template<typename DataType> CellMaterialVariableScalarRef<DataType>::
263CellMaterialVariableScalarRef(const MaterialVariableBuildInfo& vb)
264: m_private_part(PrivatePartType::BuilderType::getVariableReference(vb,MatVarSpace::MaterialAndEnvironment))
265, m_value(nullptr)
266{
267 _init();
268}
269
270/*---------------------------------------------------------------------------*/
271/*---------------------------------------------------------------------------*/
272
273template<typename DataType> CellMaterialVariableScalarRef<DataType>::
274CellMaterialVariableScalarRef(const CellMaterialVariableScalarRef<DataType>& rhs)
275: m_private_part(rhs.m_private_part)
276, m_value(nullptr)
277{
278 // Il faut incrémenter manuellement le compteur de référence car normalement
279 // cela est fait dans getReference() mais ici on ne l'appelle pas
280 if (m_private_part)
281 m_private_part->incrementReference();
282
283 _init();
284}
285
286/*---------------------------------------------------------------------------*/
287/*---------------------------------------------------------------------------*/
288
289/*---------------------------------------------------------------------------*/
290/*---------------------------------------------------------------------------*/
291
292template<typename DataType> void
293CellMaterialVariableScalarRef<DataType>::
294_init()
295{
296 if (m_private_part){
297 _setContainerView();
298 _internalInit(m_private_part->toMeshMaterialVariable());
299 }
300}
301
302/*---------------------------------------------------------------------------*/
303/*---------------------------------------------------------------------------*/
304
305template<typename DataType> void
306CellMaterialVariableScalarRef<DataType>::
307refersTo(const CellMaterialVariableScalarRef<DataType>& rhs)
308{
309 if (rhs.m_private_part==m_private_part)
310 return;
311 if (_isRegistered())
312 unregisterVariable();
313 m_private_part = rhs.m_private_part;
314 m_container_value = {};
315 m_value = nullptr;
316
317 // Il faut incrémenter manuellement le compteur de référence car normalement
318 // cela est fait dans getReference() mais ici on ne l'appelle pas
319 if (m_private_part)
320 m_private_part->incrementReference();
321 _init();
322}
323
324/*---------------------------------------------------------------------------*/
325/*---------------------------------------------------------------------------*/
326
327template<typename DataType> void
328CellMaterialVariableScalarRef<DataType>::
329updateFromInternal()
330{
331 _setContainerView();
332}
333
334/*---------------------------------------------------------------------------*/
335/*---------------------------------------------------------------------------*/
336
337template<typename DataType> DataType
338CellMaterialVariableScalarRef<DataType>::
339matValue(AllEnvCell c,Int32 mat_id) const
340{
341 ENUMERATE_CELL_ENVCELL(ienvcell,c){
342 ENUMERATE_CELL_MATCELL(imatcell,(*ienvcell)){
343 MatCell mc = *imatcell;
344 Int32 mid = mc.materialId();
345 if (mid==mat_id)
346 return this->operator[](imatcell);
347 }
348 }
349 return DataType();
350}
351
352/*---------------------------------------------------------------------------*/
353/*---------------------------------------------------------------------------*/
354
355template<typename DataType> DataType
356CellMaterialVariableScalarRef<DataType>::
357envValue(AllEnvCell c,Int32 env_id) const
358{
359 ENUMERATE_CELL_ENVCELL(ienvcell,c){
360 EnvCell ec = *ienvcell;
361 Int32 eid = ec.environmentId();
362 if (eid==env_id)
363 return this->operator[](ienvcell);
364 }
365 return DataType();
366}
367
368/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
370/*!
371 * \brief Remplit les valeurs de la variable pour un matériau.
372 *
373 * Cette méthode effectue l'opération suivante:
374 \code
375 * Integer index=0;
376 * ENUMERATE_MATCELL(imatcell,mat){
377 * matvar[imatcell] = values[index];
378 * ++index;
379 * }
380 \endcode
381*/
382template<typename DataType> void
383CellMaterialVariableScalarRef<DataType>::
384fillFromArray(IMeshMaterial* mat,ConstArrayView<DataType> values)
385{
386 m_private_part->fillFromArray(mat,values);
387}
388
389/*---------------------------------------------------------------------------*/
390/*---------------------------------------------------------------------------*/
391/*!
392 * \brief Remplit les valeurs de la variable pour un matériau.
393 *
394 * Cette méthode effectue l'opération suivante:
395 \code
396 * Integer index=0;
397 * ENUMERATE_MATCELL(imatcell,mat){
398 * matvar[imatcell] = values[index];
399 * ++index;
400 * }
401 \endcode
402*/
403template<typename DataType> void
404CellMaterialVariableScalarRef<DataType>::
405fillFromArray(IMeshMaterial* mat,ConstArrayView<DataType> values,Int32ConstArrayView indexes)
406{
407 m_private_part->fillFromArray(mat,values,indexes);
408}
409
410/*---------------------------------------------------------------------------*/
411/*---------------------------------------------------------------------------*/
412/*!
413 * \brief Remplit un tableau à partir des valeurs de la variable pour un matériau.
414 *
415 * Cette méthode effectue l'opération suivante:
416 \code
417 * Integer index=0;
418 * ENUMERATE_MATCELL(imatcell,mat){
419 * values[index] = matvar[imatcell];
420 * ++index;
421 * }
422 \endcode
423*/
424template<typename DataType> void
425CellMaterialVariableScalarRef<DataType>::
426fillToArray(IMeshMaterial* mat,ArrayView<DataType> values)
427{
428 m_private_part->fillToArray(mat,values);
429}
430
431/*---------------------------------------------------------------------------*/
432/*---------------------------------------------------------------------------*/
433/*!
434 * \brief Remplit un tableau à partir des valeurs de la variable pour un matériau.
435 *
436 * Cette méthode effectue l'opération suivante:
437 \code
438 * Integer index=0;
439 * ENUMERATE_MATCELL(imatcell,mat){
440 * values[index] = matvar[imatcell];
441 * ++index;
442 * }
443 \endcode
444*/
445template<typename DataType> void
446CellMaterialVariableScalarRef<DataType>::
447fillToArray(IMeshMaterial* mat,ArrayView<DataType> values,Int32ConstArrayView indexes)
448{
449 m_private_part->fillToArray(mat,values,indexes);
450}
451
452/*---------------------------------------------------------------------------*/
453/*---------------------------------------------------------------------------*/
454/*!
455 * \brief Remplit un tableau à partir des valeurs de la variable pour un matériau.
456 *
457 * Le tableau \a values est redimensionné si besoin.
458 */
459template<typename DataType> void
460CellMaterialVariableScalarRef<DataType>::
461fillToArray(IMeshMaterial* mat,Array<DataType>& values)
462{
463 values.resize(mat->cells().size());
464 fillToArray(mat,values.view());
465}
466
467/*---------------------------------------------------------------------------*/
468/*---------------------------------------------------------------------------*/
469/*!
470 * \brief Remplit un tableau à partir des valeurs de la variable pour un matériau.
471 *
472 * Le tableau \a values est redimensionné si besoin.
473 */
474template<typename DataType> void
475CellMaterialVariableScalarRef<DataType>::
476fillToArray(IMeshMaterial* mat,Array<DataType>& values,Int32ConstArrayView indexes)
477{
478 values.resize(mat->cells().size());
479 fillToArray(mat,values.view(),indexes);
480}
481
482/*---------------------------------------------------------------------------*/
483/*---------------------------------------------------------------------------*/
484/*!
485 * \brief Remplit les valeurs partielles et globales de la variable avec la valeur \a value
486 */
487template<typename DataType> void
488CellMaterialVariableScalarRef<DataType>::
489fill(const DataType& value)
490{
491 globalVariable().fill(value);
492 fillPartialValues(value);
493}
494
495/*---------------------------------------------------------------------------*/
496/*---------------------------------------------------------------------------*/
497/*!
498 * \brief Remplit les valeurs partielles de la variable avec la valeur \a value
499 */
500template<typename DataType> void
501CellMaterialVariableScalarRef<DataType>::
502fillPartialValues(const DataType& value)
503{
504 m_private_part->fillPartialValues(value);
505}
506
507/*---------------------------------------------------------------------------*/
508/*---------------------------------------------------------------------------*/
509
510/*---------------------------------------------------------------------------*/
511/*---------------------------------------------------------------------------*/
512
513template<typename DataType> MeshVariableScalarRefT<Cell,DataType>&
514CellMaterialVariableScalarRef<DataType>::
515globalVariable()
516{
517 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
518 if (!rt)
519 ARCANE_FATAL("null global variable");
520 return *rt;
521}
522
523/*---------------------------------------------------------------------------*/
524/*---------------------------------------------------------------------------*/
525
526template<typename DataType> const MeshVariableScalarRefT<Cell,DataType>&
527CellMaterialVariableScalarRef<DataType>::
528globalVariable() const
529{
530 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
531 if (!rt)
532 ARCANE_FATAL("null global variable");
533 return *rt;
534}
535
536/*---------------------------------------------------------------------------*/
537/*---------------------------------------------------------------------------*/
538
539template<typename DataType> void
540CellMaterialVariableScalarRef<DataType>::
541_setContainerView()
542{
543 if (m_private_part){
544 m_container_value = m_private_part->_internalFullValuesView();
545 m_value = m_container_value.data();
546 }
547 else{
548 m_container_value = {};
549 m_value = nullptr;
550 }
551}
552
553/*---------------------------------------------------------------------------*/
554/*---------------------------------------------------------------------------*/
555
556/*---------------------------------------------------------------------------*/
557/*---------------------------------------------------------------------------*/
558
559// TODO: fusionner avec la version scalaire
560template<typename DataType> CellMaterialVariableArrayRef<DataType>::
561CellMaterialVariableArrayRef(const VariableBuildInfo& vb)
562: CellMaterialVariableArrayRef(MaterialVariableBuildInfo(nullptr,vb))
563{
564}
565
566/*---------------------------------------------------------------------------*/
567/*---------------------------------------------------------------------------*/
568
569// TODO: fusionner avec la version scalaire
570template<typename DataType> CellMaterialVariableArrayRef<DataType>::
571CellMaterialVariableArrayRef(const MaterialVariableBuildInfo& vb)
572: m_private_part(PrivatePartType::BuilderType::getVariableReference(vb,MatVarSpace::MaterialAndEnvironment))
573, m_value(nullptr)
574{
575 _init();
576}
577
578/*---------------------------------------------------------------------------*/
579/*---------------------------------------------------------------------------*/
580
581// TODO: fusionner avec la version scalaire
582template<typename DataType> CellMaterialVariableArrayRef<DataType>::
583CellMaterialVariableArrayRef(const CellMaterialVariableArrayRef<DataType>& rhs)
584: m_private_part(rhs.m_private_part)
585, m_value(nullptr)
586{
587 // Il faut incrémenter manuellement le compteur de référence car normalement
588 // cela est fait dans getReference() mais ici on ne l'appelle pas
589 if (m_private_part)
590 m_private_part->incrementReference();
591
592 _init();
593}
594
595/*---------------------------------------------------------------------------*/
596/*---------------------------------------------------------------------------*/
597
598// TODO: fusionner avec la version scalaire
599template<typename DataType> void
600CellMaterialVariableArrayRef<DataType>::
601_init()
602{
603 if (m_private_part){
604 _setContainerView();
605 _internalInit(m_private_part->toMeshMaterialVariable());
606 }
607}
608
609/*---------------------------------------------------------------------------*/
610/*---------------------------------------------------------------------------*/
611
612// TODO: fusionner avec la version scalaire
613template<typename DataType> void
614CellMaterialVariableArrayRef<DataType>::
615refersTo(const CellMaterialVariableArrayRef<DataType>& rhs)
616{
617 if (rhs.m_private_part==m_private_part)
618 return;
619 if (_isRegistered())
620 unregisterVariable();
621
622 m_private_part = rhs.m_private_part;
623 m_value = nullptr;
624 m_container_value = {};
625
626 // Il faut incrémenter manuellement le compteur de référence car normalement
627 // cela est fait dans getReference() mais ici on ne l'appelle pas
628 if (m_private_part)
629 m_private_part->incrementReference();
630 _init();
631}
632
633/*---------------------------------------------------------------------------*/
634/*---------------------------------------------------------------------------*/
635
636// TODO: fusionner avec la version scalaire
637template<typename DataType> void
638CellMaterialVariableArrayRef<DataType>::
639updateFromInternal()
640{
641 _setContainerView();
642}
643
644/*---------------------------------------------------------------------------*/
645/*---------------------------------------------------------------------------*/
646
647template<typename DataType> MeshVariableArrayRefT<Cell,DataType>&
648CellMaterialVariableArrayRef<DataType>::
649globalVariable()
650{
651 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
652 if (!rt)
653 ARCANE_FATAL("null global variable");
654 return *rt;
655}
656
657/*---------------------------------------------------------------------------*/
658/*---------------------------------------------------------------------------*/
659
660template<typename DataType> const MeshVariableArrayRefT<Cell,DataType>&
661CellMaterialVariableArrayRef<DataType>::
662globalVariable() const
663{
664 GlobalVariableRefType* rt = m_private_part->globalVariableReference();
665 if (!rt)
666 ARCANE_FATAL("null global variable");
667 return *rt;
668}
669
670/*---------------------------------------------------------------------------*/
671/*---------------------------------------------------------------------------*/
672
673template<typename DataType> void
674CellMaterialVariableArrayRef<DataType>::
675resize(Integer dim2_size)
676{
677 m_private_part->resize(dim2_size);
678}
679
680/*---------------------------------------------------------------------------*/
681/*---------------------------------------------------------------------------*/
682
683template<typename DataType> void
684CellMaterialVariableArrayRef<DataType>::
685_setContainerView()
686{
687 if (m_private_part){
688 m_container_value = m_private_part->_internalFullValuesView();
689 m_value = m_container_value.data();
690 }
691 else{
692 m_container_value = {};
693 m_value = nullptr;
694 }
695}
696
697/*---------------------------------------------------------------------------*/
698/*---------------------------------------------------------------------------*/
699
700/*---------------------------------------------------------------------------*/
701/*---------------------------------------------------------------------------*/
702
703#define ARCANE_INSTANTIATE_MAT(type) \
704 template class ARCANE_TEMPLATE_EXPORT CellMaterialVariableScalarRef<type>;\
705 template class ARCANE_TEMPLATE_EXPORT CellMaterialVariableArrayRef<type>
706
707ARCANE_INSTANTIATE_MAT(Byte);
708ARCANE_INSTANTIATE_MAT(Int8);
709ARCANE_INSTANTIATE_MAT(Int16);
710ARCANE_INSTANTIATE_MAT(Int32);
711ARCANE_INSTANTIATE_MAT(Int64);
712ARCANE_INSTANTIATE_MAT(BFloat16);
713ARCANE_INSTANTIATE_MAT(Float16);
714ARCANE_INSTANTIATE_MAT(Float32);
715ARCANE_INSTANTIATE_MAT(Real);
716ARCANE_INSTANTIATE_MAT(Real2);
717ARCANE_INSTANTIATE_MAT(Real3);
718ARCANE_INSTANTIATE_MAT(Real2x2);
719ARCANE_INSTANTIATE_MAT(Real3x3);
720
721/*---------------------------------------------------------------------------*/
722/*---------------------------------------------------------------------------*/
723
724} // End namespace Arcane::Materials
725
726/*---------------------------------------------------------------------------*/
727/*---------------------------------------------------------------------------*/
ARCANE_THROW
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Definition ArcaneGlobal.h:753
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:764
Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94
Arcane::Array
Classe de base des vecteurs 1D de données.
Definition arccore/src/collections/arccore/collections/Array.h:1007
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/collections/arccore/collections/Array.h:1213
Arcane::Array::view
ArrayView< T > view() const
Vue mutable sur ce tableau.
Definition arccore/src/collections/arccore/collections/Array.h:1106
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::ItemGroup::size
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
Arcane::Materials::AllEnvCell
Maille arcane avec info matériaux et milieux.
Definition core/materials/MatItem.h:166
Arcane::Materials::CellMaterialVariableArrayRef
Variable tableau sur les mailles d'un matériau du maillage. Pour l'instant, cette classe n'est instan...
Definition core/materials/MeshMaterialVariableRef.h:371
Arcane::Materials::CellMaterialVariableArrayRef::CellMaterialVariableArrayRef
CellMaterialVariableArrayRef()=delete
Constructeur vide (interdit)
Arcane::Materials::CellMaterialVariableArrayRef::globalVariable
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
Definition MeshMaterialVariableRef.cc:649
Arcane::Materials::CellMaterialVariableArrayRef::refersTo
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshMaterialVariableRef.cc:615
Arcane::Materials::CellMaterialVariableArrayRef::resize
void resize(Integer dim2_size)
Redimensionne le nombre d'éléments du tableau.
Definition MeshMaterialVariableRef.cc:675
Arcane::Materials::CellMaterialVariableScalarRef
Variable scalaire sur les mailles d'un matériau du maillage. Pour l'instant, cette classe n'est insta...
Definition core/materials/MeshMaterialVariableRef.h:212
Arcane::Materials::CellMaterialVariableScalarRef::matValue
DataType matValue(AllEnvCell c, Int32 mat_id) const
Valeur de la variable pour le matériau d'index mat_id de la maille ou 0 si absent de la maille.
Definition MeshMaterialVariableRef.cc:339
Arcane::Materials::CellMaterialVariableScalarRef::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 MeshMaterialVariableRef.cc:357
Arcane::Materials::CellMaterialVariableScalarRef::fill
void fill(const DataType &value)
Remplit les valeurs partielles et globales de la variable avec la valeur value.
Definition MeshMaterialVariableRef.cc:489
Arcane::Materials::CellMaterialVariableScalarRef::fillPartialValues
void fillPartialValues(const DataType &value)
Remplit les valeurs partielles de la variable avec la valeur value.
Definition MeshMaterialVariableRef.cc:502
Arcane::Materials::CellMaterialVariableScalarRef::fillFromArray
void fillFromArray(IMeshMaterial *mat, ConstArrayView< DataType > values)
Remplit les valeurs de la variable pour un matériau.
Definition MeshMaterialVariableRef.cc:384
Arcane::Materials::CellMaterialVariableScalarRef::globalVariable
GlobalVariableRefType & globalVariable()
Variable globale associée à cette variable matériau.
Definition MeshMaterialVariableRef.cc:515
Arcane::Materials::CellMaterialVariableScalarRef::refersTo
virtual void refersTo(const ThatClass &rhs)
Positionne la référence de l'instance à la variable rhs.
Definition MeshMaterialVariableRef.cc:307
Arcane::Materials::CellMaterialVariableScalarRef::CellMaterialVariableScalarRef
CellMaterialVariableScalarRef()=delete
Constructeur vide (interdit)
Arcane::Materials::CellMaterialVariableScalarRef::fillToArray
void fillToArray(IMeshMaterial *mat, ArrayView< DataType > values)
Remplit un tableau à partir des valeurs de la variable pour un matériau.
Definition MeshMaterialVariableRef.cc:426
Arcane::Materials::EnvCell
Maille arcane d'un milieu.
Definition core/materials/MatItem.h:106
Arcane::Materials::EnvCell::environmentId
__host__ __device__ Int32 environmentId() const
Identifiant du milieu.
Definition core/materials/MatItem.h:137
Arcane::Materials::IMeshComponent::cells
virtual CellGroup cells() const =0
Groupe des mailles de ce matériau.
Arcane::Materials::IMeshMaterialVariable
Interface d'une variable matériau d'un maillage.
Definition core/materials/IMeshMaterialVariable.h:47
Arcane::Materials::IMeshMaterialVariable::globalVariable
virtual IVariable * globalVariable() const =0
Variable globale sur le maillage associée.
Arcane::Materials::IMeshMaterial
Interface d'un matériau d'un maillage.
Definition core/materials/IMeshMaterial.h:53
Arcane::Materials::MatCell
Représente un matériau d'une maille multi-matériau.
Definition core/materials/MatItem.h:49
Arcane::Materials::MatCell::materialId
__host__ __device__ Int32 materialId() const
Identifiant du matériau.
Definition core/materials/MatItem.h:79
Arcane::Materials::MeshMaterialVariableRef
Classe de base des références aux variables matériaux.
Definition core/materials/MeshMaterialVariableRef.h:47
Arcane::Materials::MeshMaterialVariableRef::materialVariable
IMeshMaterialVariable * materialVariable() const
Variable matériau associée.
Definition core/materials/MeshMaterialVariableRef.h:113
Arcane::Materials::MeshMaterialVariableRef::unregisterVariable
void unregisterVariable()
Supprime l'enregistrement de la variable (interne)
Definition MeshMaterialVariableRef.cc:60
Arcane::MeshVariableArrayRefT
Variable tableau sur un type d'entité du maillage.
Definition MeshVariableArrayRef.h:116
Arcane::MeshVariableScalarRefT
Variable scalaire sur un type d'entité du maillage.
Definition MeshVariableScalarRef.h:207
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::VariableBuildInfo
Paramètres nécessaires à la construction d'une variable.
Definition VariableBuildInfo.h:43
Arcane::VariableRef
Référence à une variable.
Definition VariableRef.h:56
Arcane::VariableRef::variable
IVariable * variable() const
Variable associée.
Definition VariableRef.h:126
ENUMERATE_CELL_MATCELL
#define ENUMERATE_CELL_MATCELL(iname, env_cell)
Macro pour itérer sur tous les matériaux d'une maille.
Definition core/materials/MatItemEnumerator.h:649
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:195
Arcane::Materials::MatVarSpace::MaterialAndEnvironment
@ MaterialAndEnvironment
Variable ayant des valeurs sur les milieux et matériaux.
Definition MaterialsCoreGlobal.h:197
Arcane::Int8
std::int8_t Int8
Type entier signé sur 8 bits.
Definition ArccoreGlobal.h:180
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
Arcane::Int16
std::int16_t Int16
Type entier signé sur 16 bits.
Definition ArccoreGlobal.h:182
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:223
Arcane::Byte
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
Arcane::Float32
float Float32
Type flottant IEEE-753 simple précision.
Definition ArccoreGlobal.h:279
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184