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