Arcane  v3.14.10.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MeshEnvironment.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/* MeshEnvironment.cc (C) 2000-2024 */
9/* */
10/* Milieu d'un maillage. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/NotImplementedException.h"
15#include "arcane/utils/ITraceMng.h"
16#include "arcane/utils/FunctorUtils.h"
17#include "arcane/utils/ArgumentException.h"
18#include "arcane/utils/PlatformUtils.h"
19#include "arcane/utils/MemoryUtils.h"
20#include "arcane/utils/ArraySimdPadder.h"
21
22#include "arcane/core/IMesh.h"
23#include "arcane/core/IItemFamily.h"
24#include "arcane/core/VariableBuildInfo.h"
25#include "arcane/core/ItemGroupObserver.h"
26#include "arcane/core/internal/ItemGroupImplInternal.h"
27#include "arcane/core/materials/internal/IMeshMaterialVariableInternal.h"
28#include "arcane/core/materials/internal/IMeshMaterialMngInternal.h"
29
30#include "arcane/materials/IMeshMaterialMng.h"
31#include "arcane/materials/MatItemEnumerator.h"
32#include "arcane/materials/ComponentItemVectorView.h"
33#include "arcane/materials/IMeshMaterialVariable.h"
34#include "arcane/materials/ComponentPartItemVectorView.h"
35
36#include "arcane/materials/internal/MeshEnvironment.h"
37#include "arcane/materials/internal/MeshMaterial.h"
38#include "arcane/materials/internal/ComponentItemListBuilder.h"
39#include "arcane/materials/internal/ComponentItemInternalData.h"
40#include "arcane/materials/internal/ConstituentConnectivityList.h"
41#include "arcane/materials/internal/ConstituentItemVectorImpl.h"
42#include "arcane/materials/internal/MeshComponentPartData.h"
43
44#include "arcane/accelerator/RunQueue.h"
45#include "arcane/accelerator/RunCommandLoop.h"
46#include "arcane/accelerator/Scan.h"
47#include "arcane/accelerator/SpanViews.h"
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51
52namespace Arcane::Materials
53{
54
55/*---------------------------------------------------------------------------*/
56/*---------------------------------------------------------------------------*/
57
58class MeshEnvironmentObserver
59: public TraceAccessor
60, public IItemGroupObserver
61{
62 public:
63
64 MeshEnvironmentObserver(MeshEnvironment* env, ITraceMng* tm)
65 : TraceAccessor(tm)
66 , m_environment(env)
67 {}
68
69 public:
70
71 void executeExtend(const Int32ConstArrayView* info1) override
72 {
73 if (info1) {
74 //info(4) << "EXTEND_ENV " << m_environment->name() << " ids=" << (*info1);
75 if (m_environment->materialMng()->isInMeshMaterialExchange())
76 info() << "EXTEND_ENV_IN_LOADBALANCE " << m_environment->name()
77 << " ids=" << (*info1);
78 }
79 }
80 void executeReduce(const Int32ConstArrayView* info1) override
81 {
82 if (info1) {
83 //info(4) << "REDUCE_ENV " << m_environment->name() << " ids=" << (*info1);
84 if (m_environment->materialMng()->isInMeshMaterialExchange())
85 info() << "REDUCE_ENV_IN_LOADBALANCE " << m_environment->name()
86 << " ids=" << (*info1);
87 }
88 }
89 void executeCompact(const Int32ConstArrayView* info1) override
90 {
91 info(4) << "COMPACT_ENV " << m_environment->name();
92 if (!info1)
93 ARCANE_FATAL("No info available");
94 Int32ConstArrayView old_to_new_ids(*info1);
95 m_environment->notifyLocalIdsChanged(old_to_new_ids);
96 }
97 void executeInvalidate() override
98 {
99 info() << "WARNING: invalidate() is invalid on an environment group! partial values may be corrupted"
100 << " env=" << m_environment->name();
101 }
102 bool needInfo() const override { return true; }
103
104 private:
105
106 MeshEnvironment* m_environment;
107};
108
109/*---------------------------------------------------------------------------*/
110/*---------------------------------------------------------------------------*/
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115MeshEnvironment::
116MeshEnvironment(IMeshMaterialMng* mm, const String& name, Int16 env_id)
117: TraceAccessor(mm->traceMng())
118, m_material_mng(mm)
119, m_data(this, name, env_id, mm->_internalApi()->componentItemSharedInfo(LEVEL_ENVIRONMENT), false)
120, m_non_const_this(this)
121, m_internal_api(this)
122{
123}
124
125/*---------------------------------------------------------------------------*/
126/*---------------------------------------------------------------------------*/
127
128/*---------------------------------------------------------------------------*/
129/*---------------------------------------------------------------------------*/
130
131void MeshEnvironment::
132build()
133{
134 IMesh* mesh = m_material_mng->mesh();
135 IItemFamily* cell_family = mesh->cellFamily();
136 String group_name = m_material_mng->name() + "_" + name();
137 CellGroup cells = cell_family->findGroup(group_name, true);
138 cells._internalApi()->setAsConstituentGroup();
139
140 if (m_material_mng->isMeshModificationNotified()) {
141 m_group_observer = new MeshEnvironmentObserver(this, traceMng());
142 cells.internal()->attachObserver(this, m_group_observer);
143 }
144
145 m_data._setItems(cells);
146}
147
148/*---------------------------------------------------------------------------*/
149/*---------------------------------------------------------------------------*/
150
151void MeshEnvironment::
152addMaterial(MeshMaterial* mm)
153{
154 m_materials.add(mm);
155 m_true_materials.add(mm);
156}
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
160
161void MeshEnvironment::
162setVariableIndexer(MeshMaterialVariableIndexer* idx)
163{
164 m_data._setVariableIndexer(idx);
165 idx->setCells(m_data.items());
166 idx->setIsEnvironment(true);
167
168 // S'il n'y qu'un matériau, le variable indexer de ce matériau est
169 // aussi 'idx' mais avec un autre groupe associé. Pour que tout soit
170 // cohérent, il faut être sur que ce matériau a aussi le même groupe.
171 // TODO: pour garantir la cohérence, il faudrait supprimer
172 // dans m_data le groupe d'entité.
173 if (m_true_materials.size() == 1)
174 m_true_materials[0]->componentData()->_setItems(m_data.items());
175 m_data._buildPartData();
176 for (MeshMaterial* mat : m_true_materials)
177 mat->componentData()->_buildPartData();
178}
179
180/*---------------------------------------------------------------------------*/
181/*---------------------------------------------------------------------------*/
182
183void MeshEnvironment::
184computeNbMatPerCell()
185{
186 info(4) << "ComputeNbMatPerCell env=" << name();
187 Integer nb_mat = m_materials.size();
188 Integer total = 0;
189 for (Integer i = 0; i < nb_mat; ++i) {
190 IMeshMaterial* mat = m_materials[i];
191 CellGroup mat_cells = mat->cells();
192 total += mat_cells.size();
193 }
194 m_total_nb_cell_mat = total;
195}
196
197/*---------------------------------------------------------------------------*/
198/*---------------------------------------------------------------------------*/
199/*!
200 * \brief Calcul les infos sur les matériaux.
201 *
202 * Cette méthode est appelée par le MeshMaterialMng et doit être appelée
203 * une fois que les m_items_internal ont été mis à jour et
204 * computeNbMatPerCell() et computeItemListForMaterials() ont été appelées
205 */
206void MeshEnvironment::
207computeMaterialIndexes(ComponentItemInternalData* item_internal_data, RunQueue& queue)
208{
209 info(4) << "Compute (V2) indexes for environment name=" << name();
210 const bool is_mono_mat = isMonoMaterial();
211 if (is_mono_mat) {
212 _computeMaterialIndexesMonoMat(item_internal_data, queue);
213 }
214 else
215 _computeMaterialIndexes(item_internal_data, queue);
216}
217
218/*---------------------------------------------------------------------------*/
219/*---------------------------------------------------------------------------*/
220
221void MeshEnvironment::
222_computeMaterialIndexes(ComponentItemInternalData* item_internal_data, RunQueue& queue)
223{
224 IItemFamily* cell_family = cells().itemFamily();
225 Integer max_local_id = cell_family->maxLocalId();
226
227 ComponentItemInternalRange mat_items_internal_range = m_mat_internal_data_range;
228
229 UniqueArray<Int32> cells_index(platform::getDefaultDataAllocator());
230 cells_index.resize(max_local_id);
231 UniqueArray<Int32> cells_pos(platform::getDefaultDataAllocator());
232 cells_pos.resize(max_local_id);
233
234 // TODO: regarder comment supprimer ce tableau cells_env qui n'est normalement pas utile
235 // car on doit pouvoir directement utiliser les m_items_internal
236 UniqueArray<ConstituentItemIndex> cells_env(platform::getDefaultDataAllocator());
237 cells_env.resize(max_local_id);
238
239 Int32ConstArrayView local_ids = variableIndexer()->localIds();
240 ConstituentItemLocalIdListView constituent_item_list_view = m_data.constituentItemListView();
241 const bool do_old = false;
242 if (do_old) {
243 Integer cell_index = 0;
244 for (Integer z = 0, nb = local_ids.size(); z < nb; ++z) {
245 Int32 lid = local_ids[z];
246 matimpl::ConstituentItemBase env_item = constituent_item_list_view._constituenItemBase(z);
247 Int32 nb_mat = env_item.nbSubItem();
248 cells_index[lid] = cell_index;
249 cell_index += nb_mat;
250 }
251 }
252 else {
253 // Calcul l'indice de la première MatCell pour chaque Cell.
254 Int32 nb_id = local_ids.size();
255 {
256 Accelerator::GenericScanner scanner(queue);
257 auto cells_index_view = viewOut(queue, cells_index);
258
259 auto getter = [=] ARCCORE_HOST_DEVICE(Int32 index) -> Int32 {
260 return constituent_item_list_view._constituenItemBase(index).nbSubItem();
261 };
262 auto setter = [=] ARCCORE_HOST_DEVICE(Int32 index, Int32 value) {
263 Int32 lid = local_ids[index];
264 cells_index_view[lid] = value;
265 };
266 Accelerator::ScannerSumOperator<Int32> op;
267 scanner.applyWithIndexExclusive(nb_id, 0, getter, setter, op, A_FUNCINFO);
268 }
269 }
270 {
271 auto command = makeCommand(queue);
272 auto cells_env_view = viewOut(command, cells_env);
273 auto cells_index_view = viewIn(command, cells_index);
274 auto cells_pos_view = viewOut(command, cells_pos);
275 Int32 nb_id = local_ids.size();
276 command << RUNCOMMAND_LOOP1(iter, nb_id)
277 {
278 auto [z] = iter();
279 Int32 lid = local_ids[z];
280 matimpl::ConstituentItemBase env_item = constituent_item_list_view._constituenItemBase(z);
281 Int32 nb_mat = env_item.nbSubItem();
282 Int32 cell_index = cells_index_view[lid];
283 cells_pos_view[lid] = cell_index;
284 if (nb_mat != 0) {
285 env_item._setFirstSubItem(mat_items_internal_range[cell_index]);
286 }
287 cells_env_view[lid] = env_item.constituentItemIndex();
288 };
289 }
290 {
291 Integer nb_mat = m_true_materials.size();
292 ComponentItemInternalRange mat_item_internal_range = m_mat_internal_data_range;
293 for (Integer i = 0; i < nb_mat; ++i) {
294 MeshMaterial* mat = m_true_materials[i];
295 Int16 mat_id = mat->componentId();
296 const MeshMaterialVariableIndexer* var_indexer = mat->variableIndexer();
297 CellGroup mat_cells = mat->cells();
298 info(4) << "COMPUTE (V2) mat_cells mat=" << mat->name() << " nb_cell=" << mat_cells.size()
299 << " mat_id=" << mat_id << " index=" << var_indexer->index();
300
301 mat->resizeItemsInternal(var_indexer->nbItem());
302
303 auto command = makeCommand(queue);
304 auto matvar_indexes = viewIn(command, var_indexer->matvarIndexes());
305 auto local_ids = viewIn(command, var_indexer->localIds());
306 SmallSpan<Int32> cells_pos_view(cells_pos);
307 auto cells_env_view = viewIn(command, cells_env);
308 ComponentItemSharedInfo* mat_shared_info = item_internal_data->matSharedInfo();
309 SmallSpan<ConstituentItemIndex> mat_id_list = mat->componentData()->m_constituent_local_id_list.mutableLocalIds();
310 const Int32 nb_id = local_ids.size();
311 Span<Int32> mat_cells_local_id = mat_cells._internalApi()->itemsLocalId();
312 command << RUNCOMMAND_LOOP1(iter, nb_id)
313 {
314 auto [z] = iter();
315 MatVarIndex mvi = matvar_indexes[z];
316 Int32 lid = local_ids[z];
317 Int32 pos = cells_pos_view[lid];
318 ++cells_pos_view[lid];
319 ConstituentItemIndex cii = mat_item_internal_range[pos];
320 matimpl::ConstituentItemBase ref_ii(mat_shared_info, cii);
321 mat_id_list[z] = cii;
322 ref_ii._setSuperAndGlobalItem(cells_env_view[lid], ItemLocalId(lid));
323 ref_ii._setComponent(mat_id);
324 ref_ii._setVariableIndex(mvi);
325 // Le rang 0 met à jour le padding SIMD du groupe associé au matériau
326 if (z == 0)
327 ArraySimdPadder::applySimdPaddingView(mat_cells_local_id);
328 };
329 mat_cells._internalApi()->notifySimdPaddingDone();
330 }
331 }
332}
333
334/*---------------------------------------------------------------------------*/
335/*---------------------------------------------------------------------------*/
336/*!
337 * \brief Calcul les infos sur les matériaux en mono-matériaux.
338 *
339 * Spécialisation pour le cas où le milieu n'a qu'un matériau.
340 */
341void MeshEnvironment::
342_computeMaterialIndexesMonoMat(ComponentItemInternalData* item_internal_data, RunQueue& queue)
343{
344 ConstituentItemLocalIdListView constituent_item_list_view = m_data.constituentItemListView();
345
346 MeshMaterial* mat = m_true_materials[0];
347 const Int16 mat_id = mat->componentId();
348 const MeshMaterialVariableIndexer* var_indexer = mat->variableIndexer();
349 CellGroup mat_cells = mat->cells();
350 info(4) << "COMPUTE (V2) mat_cells mat=" << mat->name() << " nb_cell=" << mat_cells.size()
351 << " mat_id=" << mat_id << " index=" << var_indexer->index();
352
353 mat->resizeItemsInternal(var_indexer->nbItem());
354
355 auto command = makeCommand(queue);
356 auto matvar_indexes = viewIn(command, var_indexer->matvarIndexes());
357 auto local_ids = viewIn(command, var_indexer->localIds());
358 ComponentItemSharedInfo* mat_shared_info = item_internal_data->matSharedInfo();
359 ComponentItemInternalRange mat_item_internal_range = m_mat_internal_data_range;
360 SmallSpan<ConstituentItemIndex> mat_id_list = mat->componentData()->m_constituent_local_id_list.mutableLocalIds();
361 const Int32 nb_id = local_ids.size();
362 Span<Int32> mat_cells_local_id = mat_cells._internalApi()->itemsLocalId();
363 command << RUNCOMMAND_LOOP1(iter, nb_id)
364 {
365 auto [z] = iter();
366 MatVarIndex mvi = matvar_indexes[z];
367 const Int32 lid = local_ids[z];
368 const Int32 pos = z;
369 matimpl::ConstituentItemBase env_item = constituent_item_list_view._constituenItemBase(z);
370 ConstituentItemIndex cii = mat_item_internal_range[pos];
371 env_item._setFirstSubItem(cii);
372
373 matimpl::ConstituentItemBase ref_ii(mat_shared_info, cii);
374 mat_id_list[z] = cii;
375 ref_ii._setSuperAndGlobalItem(env_item.constituentItemIndex(), ItemLocalId(lid));
376 ref_ii._setComponent(mat_id);
377 ref_ii._setVariableIndex(mvi);
378 // Le rang 0 met à jour le padding SIMD du groupe associé au matériau
379 if (z == 0)
380 ArraySimdPadder::applySimdPaddingView(mat_cells_local_id);
381 };
382 mat_cells._internalApi()->notifySimdPaddingDone();
383}
384
385/*---------------------------------------------------------------------------*/
386/*---------------------------------------------------------------------------*/
387/*!
388 * \brief Calcul pour les mailles des matériaux du milieu leur emplacement
389 * dans le tableau d'indexation des variables.
390 */
391void MeshEnvironment::
392computeItemListForMaterials(const ConstituentConnectivityList& connectivity_list)
393{
394 info(4) << "ComputeItemListForMaterials (V2)";
395 ConstArrayView<Int16> nb_env_per_cell = connectivity_list.cellsNbEnvironment();
396 const Int16 env_id = componentId();
397 // Calcul pour chaque matériau le nombre de mailles mixtes
398 // TODO: a faire dans MeshMaterialVariableIndexer
399 for (MeshMaterial* mat : m_true_materials) {
400 MeshMaterialVariableIndexer* var_indexer = mat->variableIndexer();
401 CellGroup cells = var_indexer->cells();
402 Integer var_nb_cell = cells.size();
403
404 ComponentItemListBuilderOld list_builder(var_indexer, 0);
405
406 info(4) << "MAT_INDEXER mat=" << mat->name() << " NB_CELL=" << var_nb_cell << " name=" << cells.name();
407 ENUMERATE_CELL (icell, cells) {
408 Int32 lid = icell.itemLocalId();
409 // On ne prend l'indice global que si on est le seul matériau et le seul
410 // milieu de la maille. Sinon, on prend un indice multiple
411 if (nb_env_per_cell[lid] > 1 || connectivity_list.cellNbMaterial(icell, env_id) > 1)
412 list_builder.addPartialItem(lid);
413 else
414 list_builder.addPureItem(lid);
415 }
416
417 if (traceMng()->verbosityLevel() >= 5)
418 info() << "MAT_NB_MULTIPLE_CELL (V2) mat=" << var_indexer->name()
419 << " nb_in_global=" << list_builder.pureMatVarIndexes().size()
420 << " (ids=" << list_builder.pureMatVarIndexes() << ")"
421 << " nb_in_multiple=" << list_builder.partialMatVarIndexes().size()
422 << " (ids=" << list_builder.partialLocalIds() << ")";
423 var_indexer->endUpdate(list_builder);
424 }
425}
426
427/*---------------------------------------------------------------------------*/
428/*---------------------------------------------------------------------------*/
429
430void MeshEnvironment::
431notifyLocalIdsChanged(Int32ConstArrayView old_to_new_ids)
432{
433 // NOTE:
434 // Cette méthode est appelée lorsqu'il y a un compactage du maillage
435 // et le groupe d'entité associé à ce milieu vient d'être compacté.
436 // Comme actuellement il n'y a pas d'observeurs pour l'ajout
437 // ou la suppression de mailles du groupe, il est possible
438 // lorsque cette méthode est appelée que les infos des milieux et
439 // matériaux ne soient pas à jour (par exemple, la liste des local_ids
440 // du m_variable_indexer n'a pas les mêmes valeurs que cells().
441 // Pour l'instant ce n'est pas très grave car tout est écrasé après
442 // chaque modif sur un matériau ou un milieu.
443 // A terme, il faudra prendre cela en compte lorsque l'ajout
444 // où la suppression de mailles matériaux sera optimisée.
445 info(4) << "Changing (V3) local ids references env=" << name();
446 info(4) << "CurrentCells name=" << cells().name()
447 << " n=" << cells().view().localIds().size();
448 info(4) << "MatVarIndex name=" << cells().name()
449 << " n=" << variableIndexer()->matvarIndexes().size();
450 Integer nb_mat = m_true_materials.size();
451 info(4) << "NotifyLocalIdsChanged env=" << name() << " nb_mat=" << nb_mat
452 << " old_to_new_ids.size=" << old_to_new_ids.size();
453
454 // Si le milieu n'a qu'un seul matériau, ils partagent le même variable_indexer
455 // donc il ne faut changer les ids qu'une seule fois. Par contre, le
456 // tableau m_items_internal n'est pas partagé entre le matériau
457 // et le milieu donc il faut recalculer les infos séparément.
458 // Il faut le faire pour le milieu avant de mettre à jour les infos du matériau car
459 // une fois ceci fait la valeur m_variable_indexer->m_local_ids_in_indexes_view
460 // aura changé et il ne sera plus possible de déterminer la correspondance
461 // entre les nouveaux et les anciens localId
462
463 if (nb_mat == 1) {
464 m_data._changeLocalIdsForInternalList(old_to_new_ids);
465 MeshMaterial* true_mat = m_true_materials[0];
466 _changeIds(true_mat->componentData(), old_to_new_ids);
467 }
468 else {
469 // Change les infos des matériaux
470 for (Integer i = 0; i < nb_mat; ++i) {
471 MeshMaterial* true_mat = m_true_materials[i];
472 info(4) << "ChangeIds MAT i=" << i << " MAT=" << true_mat->name();
473 _changeIds(true_mat->componentData(), old_to_new_ids);
474 }
475 // Change les infos du milieu
476 _changeIds(componentData(), old_to_new_ids);
477 }
478
479 // Reconstruit les infos sur les mailles pures et mixtes.
480 // Il faut le faire une fois que tous les valeurs sont à jour.
481 {
482 RunQueue& queue = m_material_mng->_internalApi()->runQueue();
483 for (Integer i = 0; i < nb_mat; ++i) {
484 MeshMaterial* true_mat = m_true_materials[i];
485 true_mat->componentData()->_rebuildPartData(queue);
486 }
487 componentData()->_rebuildPartData(queue);
488 }
489
490 checkValid();
491}
492
493/*---------------------------------------------------------------------------*/
494/*---------------------------------------------------------------------------*/
495
496void MeshEnvironment::
497_changeIds(MeshComponentData* cdata, Int32ConstArrayView old_to_new_ids)
498{
499 info(4) << "ChangeIds() (V4) for name=" << cdata->name();
500 info(4) << "Use new version for ChangeIds()";
501
502 cdata->_changeLocalIdsForInternalList(old_to_new_ids);
503 cdata->variableIndexer()->changeLocalIds(old_to_new_ids);
504}
505
506/*---------------------------------------------------------------------------*/
507/*---------------------------------------------------------------------------*/
508
509EnvCell MeshEnvironment::
510findEnvCell(AllEnvCell c) const
511{
512 Int32 env_id = m_data.componentId();
513 ENUMERATE_CELL_ENVCELL (ienvcell, c) {
514 EnvCell ec = *ienvcell;
515 Int32 eid = ec.environmentId();
516 if (eid == env_id)
517 return ec;
518 }
519 return EnvCell();
520}
521
522/*---------------------------------------------------------------------------*/
523/*---------------------------------------------------------------------------*/
524
525ComponentCell MeshEnvironment::
526findComponentCell(AllEnvCell c) const
527{
528 return findEnvCell(c);
529}
530
531/*---------------------------------------------------------------------------*/
532/*---------------------------------------------------------------------------*/
533
534EnvItemVectorView MeshEnvironment::
535envView() const
536{
537 return { m_non_const_this, variableIndexer()->matvarIndexes(),
538 constituentItemListView(), variableIndexer()->localIds() };
539}
540
541/*---------------------------------------------------------------------------*/
542/*---------------------------------------------------------------------------*/
543
544ComponentItemVectorView MeshEnvironment::
545view() const
546{
547 return envView();
548}
549
550/*---------------------------------------------------------------------------*/
551/*---------------------------------------------------------------------------*/
552
553void MeshEnvironment::
554resizeItemsInternal(Integer nb_item)
555{
556 m_data._resizeItemsInternal(nb_item);
557}
558
559/*---------------------------------------------------------------------------*/
560/*---------------------------------------------------------------------------*/
561
562ComponentPurePartItemVectorView MeshEnvironment::
563pureItems() const
564{
565 return m_data._partData()->pureView();
566}
567
568/*---------------------------------------------------------------------------*/
569/*---------------------------------------------------------------------------*/
570
571ComponentImpurePartItemVectorView MeshEnvironment::
572impureItems() const
573{
574 return m_data._partData()->impureView();
575}
576
577/*---------------------------------------------------------------------------*/
578/*---------------------------------------------------------------------------*/
579
580ComponentPartItemVectorView MeshEnvironment::
581partItems(eMatPart part) const
582{
583 return m_data._partData()->partView(part);
584}
585
586/*---------------------------------------------------------------------------*/
587/*---------------------------------------------------------------------------*/
588
589EnvPurePartItemVectorView MeshEnvironment::
590pureEnvItems() const
591{
592 return { m_non_const_this, m_data._partData()->pureView() };
593}
594
595/*---------------------------------------------------------------------------*/
596/*---------------------------------------------------------------------------*/
597
598EnvImpurePartItemVectorView MeshEnvironment::
599impureEnvItems() const
600{
601 return { m_non_const_this, m_data._partData()->impureView() };
602}
603
604/*---------------------------------------------------------------------------*/
605/*---------------------------------------------------------------------------*/
606
607EnvPartItemVectorView MeshEnvironment::
608partEnvItems(eMatPart part) const
609{
610 return { m_non_const_this, m_data._partData()->partView(part) };
611}
612
613/*---------------------------------------------------------------------------*/
614/*---------------------------------------------------------------------------*/
615
616void MeshEnvironment::
617checkValid()
618{
619 if (!arcaneIsCheck())
620 return;
621
622 m_data.checkValid();
623
624 for (IMeshMaterial* mat : m_materials) {
625 mat->checkValid();
626 }
627}
628
629/*---------------------------------------------------------------------------*/
630/*---------------------------------------------------------------------------*/
631
632bool MeshEnvironment::
633isMonoMaterial() const
634{
635 bool is_mono_mat = (nbMaterial() == 1 && (cells().size() == totalNbCellMat()));
636 return is_mono_mat;
637}
638
639/*---------------------------------------------------------------------------*/
640/*---------------------------------------------------------------------------*/
641
642Int32 MeshEnvironment::InternalApi::
643variableIndexerIndex() const
644{
645 return variableIndexer()->index();
646}
647
648/*---------------------------------------------------------------------------*/
649/*---------------------------------------------------------------------------*/
650
651Ref<IConstituentItemVectorImpl> MeshEnvironment::InternalApi::
652createItemVectorImpl() const
653{
654 auto* x = new ConstituentItemVectorImpl(m_environment->m_non_const_this);
655 return makeRef<IConstituentItemVectorImpl>(x);
656}
657
658/*---------------------------------------------------------------------------*/
659/*---------------------------------------------------------------------------*/
660
661Ref<IConstituentItemVectorImpl> MeshEnvironment::InternalApi::
662createItemVectorImpl(ComponentItemVectorView rhs) const
663{
664 auto* x = new ConstituentItemVectorImpl(rhs);
665 return makeRef<IConstituentItemVectorImpl>(x);
666}
667
668/*---------------------------------------------------------------------------*/
669/*---------------------------------------------------------------------------*/
670
671} // End namespace Arcane::Materials
672
673/*---------------------------------------------------------------------------*/
674/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:809
ENUMERATE_CELL
#define ENUMERATE_CELL(name, group)
Enumérateur générique d'un groupe de mailles.
Definition ItemEnumerator.h:427
RunCommandLoop.h
Types et macros pour gérer les boucles sur les accélérateurs.
RUNCOMMAND_LOOP1
#define RUNCOMMAND_LOOP1(iter_name, x1,...)
Boucle sur accélérateur avec arguments supplémentaires pour les réductions.
Definition RunCommandLoop.h:235
Arcane::ItemGroup::name
const String & name() const
Nom du groupe.
Definition ItemGroup.h:76
Arcane::ItemGroup::size
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
Arcane::ItemGroup::_internalApi
ItemGroupImplInternal * _internalApi() const
API interne à Arcane.
Definition ItemGroup.cc:645
Arcane::Materials::IMeshMaterialMng
Interface du gestionnaire des matériaux et des milieux d'un maillage.
Definition core/materials/IMeshMaterialMng.h:58
Arcane::Materials::MeshEnvironmentObserver::needInfo
bool needInfo() const override
Indique si l'observer aura besoin d'information de transition.
Definition MeshEnvironment.cc:102
Arcane::Materials::MeshEnvironmentObserver::executeReduce
void executeReduce(const Int32ConstArrayView *info1) override
Execute l'action associée à l'extension.
Definition MeshEnvironment.cc:80
Arcane::Materials::MeshEnvironmentObserver::executeInvalidate
void executeInvalidate() override
Execute l'action associée à l'invalidation.
Definition MeshEnvironment.cc:97
Arcane::Materials::MeshEnvironmentObserver::executeExtend
void executeExtend(const Int32ConstArrayView *info1) override
Execute l'action associée à l'extension.
Definition MeshEnvironment.cc:71
Arcane::Materials::MeshEnvironmentObserver::executeCompact
void executeCompact(const Int32ConstArrayView *info1) override
Execute l'action associée au compactage.
Definition MeshEnvironment.cc:89
Arccore::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arccore::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arccore::TraceAccessor::info
TraceMessage info() const
Flot pour un message d'information.
Definition TraceAccessor.cc:101
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::CellGroup
ItemGroupT< Cell > CellGroup
Groupe de mailles.
Definition ItemTypes.h:183
Arcane::Accelerator::makeCommand
RunCommand makeCommand(const RunQueue &run_queue)
Créé une commande associée à la file run_queue.
Definition core/RunQueue.h:248
Arcane::Materials
Active toujours les traces dans les parties Arcane concernant les matériaux.
Definition ItemCompatibility.h:27
Arcane::Materials::eMatPart
eMatPart
Partie d'un composant.
Definition MaterialsCoreGlobal.h:184
Arcane::platform::getDefaultDataAllocator
IMemoryAllocator * getDefaultDataAllocator()
Allocateur par défaut pour les données.
Definition arcane/src/arcane/utils/PlatformUtils.cc:245
Arcane::viewOut
auto viewOut(MeshVariableScalarRefT< ItemType, DataType > &var)
Vue en écriture.
Definition VariableView.h:357
Arcane::arcaneIsCheck
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Definition Misc.cc:151
Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:640
Arcane::viewIn
auto viewIn(const MeshVariableScalarRefT< ItemType, DataType > &var)
Vue en lecture.
Definition VariableView.h:441
Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240