Arcane  v3.16.3.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
MeshMaterialMng.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* MeshMaterialMng.h (C) 2000-2025 */
9/* */
10/* Implémentation de la modification des matériaux et milieux. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_MATERIALS_INTERNAL_MESHMATERIALMNG_H
13#define ARCANE_MATERIALS_INTERNAL_MESHMATERIALMNG_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/TraceAccessor.h"
18#include "arcane/utils/Array.h"
19#include "arcane/utils/Mutex.h"
20
21#include "arcane/core/MeshHandle.h"
22
23#include "arcane/core/materials/IMeshMaterialMng.h"
25#include "arcane/core/materials/internal/IMeshMaterialMngInternal.h"
26
27#include "arcane/accelerator/core/Runner.h"
28#include "arcane/accelerator/core/RunQueuePool.h"
29
30#include "arcane/materials/MeshBlock.h"
31#include "arcane/materials/AllCellToAllEnvCellConverter.h"
32#include "arcane/materials/internal/MeshMaterial.h"
33#include "arcane/materials/internal/MeshEnvironment.h"
34#include "arcane/materials/internal/MeshMaterialSynchronizer.h"
35
36#include <map>
37#include <memory>
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42namespace Arcane
43{
44class IVariableMng;
45class Properties;
46class ObserverPool;
47}
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51
52namespace Arcane::Materials
53{
54
55/*---------------------------------------------------------------------------*/
56/*---------------------------------------------------------------------------*/
60class MeshMaterialMng
61: public TraceAccessor
62, public IMeshMaterialMng
63{
64 public:
65
66 friend class MeshMaterialBackup;
67
68 private:
69
71 class RunnerInfo
72 {
73 public:
74
75 explicit RunnerInfo(Runner& runner);
76
77 public:
78
79 void initializeAsyncPool(Int32 nb_queue);
80
81 public:
82
83 RunQueue runQueue(Accelerator::eExecutionPolicy policy) const;
84
85 public:
86
87 Runner m_runner;
88 RunQueue m_run_queue;
89 Accelerator::RunQueuePool m_async_queue_pool;
90 Runner m_sequential_runner;
91 RunQueue m_sequential_run_queue;
92 Runner m_multi_thread_runner;
93 RunQueue m_multi_thread_run_queue;
94 };
95
96 class InternalApi
98 {
99 public:
100
101 explicit InternalApi(MeshMaterialMng* mm)
102 : m_material_mng(mm)
103 {}
104
105 public:
106
108 {
109 return m_material_mng->getAllCellToAllEnvCellContainer();
110 }
112 {
113 return m_material_mng->createAllCellToAllEnvCell();
114 }
116 {
117 return m_material_mng->_variablesIndexer();
118 }
120 {
121 return m_material_mng->_addVariable(var);
122 }
124 {
125 return m_material_mng->_removeVariable(var);
126 }
128 {
129 return m_material_mng->_modifier();
130 }
132 {
133 return m_material_mng->_allCellsMatEnvSynchronizer();
134 }
136 {
137 return m_material_mng->_allCellsEnvOnlySynchronizer();
138 }
139 ComponentItemSharedInfo* componentItemSharedInfo(Int32 level) const override
140 {
141 return m_material_mng->componentItemSharedInfo(level);
142 }
143 RunQueue& runQueue() const override
144 {
145 return m_material_mng->runQueue();
146 }
148 {
149 return m_material_mng->asyncRunQueuePool();
150 }
152 {
153 return m_material_mng->additionalCapacityRatio();
154 }
156 {
157 return m_material_mng->m_is_use_accelerator_for_constituent_item_vector;
158 }
160 {
161 return m_material_mng->m_runner_info->runQueue(policy);
162 }
163
164 private:
165
166 MeshMaterialMng* m_material_mng = nullptr;
167 };
168
169 public:
170
171 MeshMaterialMng(const MeshHandle& mesh_handle,const String& name);
172 ~MeshMaterialMng() override;
173
174 public:
175
176 void build();
177
178 public:
179
180 IMesh* mesh() override { return m_mesh_handle.mesh(); }
182
183 public:
184
187 IMeshBlock* createBlock(const MeshBlockBuildInfo& infos) override;
188 void addEnvironmentToBlock(IMeshBlock* block,IMeshEnvironment* env) override;
189 void removeEnvironmentToBlock(IMeshBlock* block,IMeshEnvironment* env) override;
190
191 void endCreate(bool is_continue) override;
192
193 void setDataInitialisationWithZero(bool v) override { m_is_data_initialisation_with_zero = v; }
194 bool isDataInitialisationWithZero() const override { return m_is_data_initialisation_with_zero; }
195
196 void setKeepValuesAfterChange(bool v) override { m_keep_values_after_change = v; }
197 bool isKeepValuesAfterChange() const override { return m_keep_values_after_change; }
198
199 void setMeshModificationNotified(bool v) override { m_is_mesh_modification_notified = v; }
200 bool isMeshModificationNotified() const override { return m_is_mesh_modification_notified; }
201
202 void setModificationFlags(int v) override;
203 int modificationFlags() const override { return m_modification_flags; }
204
207 {
208 return m_is_allocate_scalar_environment_variable_as_material;
209 }
210
211 void setDataCompressorServiceName(const String& name) override;
212 String dataCompressorServiceName() const override { return m_data_compressor_service_name; }
213
214 String name() const override { return m_name; }
215 ConstArrayView<IMeshMaterial*> materials() const override { return m_materials; }
216 ConstArrayView<IMeshComponent*> materialsAsComponents() const override { return m_materials_as_components; }
217 ConstArrayView<IMeshEnvironment*> environments() const override { return m_environments; }
218 ConstArrayView<IMeshComponent*> environmentsAsComponents() const override { return m_environments_as_components; }
219 ConstArrayView<IMeshComponent*> components() const override { return m_components; }
220 ConstArrayView<IMeshBlock*> blocks() const override { return m_blocks; }
221
222 IMeshEnvironment* findEnvironment(const String& name,bool throw_exception=true) override;
223 IMeshBlock* findBlock(const String& name,bool throw_exception=true) override;
224
226
228 IMeshMaterialVariable* checkVariable(IVariable* global_var) override;
229
230 void dumpInfos(std::ostream& o) override;
231 void dumpCellInfos(Cell cell,std::ostream& o) override;
232
233 void checkValid() override;
234
235 void forceRecompute() override;
236
237 Mutex* variableLock() override
238 {
239 return &m_variable_lock;
240 }
241
242 bool synchronizeMaterialsInCells() override;
243 void checkMaterialsInCells(Integer max_print) override;
244
245 Int64 timestamp() const override { return m_timestamp; }
246
247 ConstArrayView<MeshEnvironment*> trueEnvironments() const { return m_true_environments; }
248 ConstArrayView<MeshMaterial*> trueMaterials() const { return m_true_materials; }
249 Int32 nbVariable() const { return static_cast<Int32>(m_full_name_variable_map.size()); }
250
251 public:
252
253 AllEnvCellVectorView _view(SmallSpan<const Int32> cells_local_id);
254
256 {
257 return this->_view(cells.view().localIds());
258 }
259
261 {
262 return this->_view(cells.localIds());
263 }
264
266 {
267 return this->_view(cells_local_id);
268 }
269
271
272 void recreateFromDump() override;
273
275
277 {
278 m_synchronize_variable_version = version;
279 }
280
282 {
283 return m_synchronize_variable_version;
284 }
285
286 bool isInMeshMaterialExchange() const override;
287
289 {
290 return m_variable_factory_mng;
291 }
292
294 {
295 m_is_use_material_value_when_removing_partial_value = v;
296 }
297 bool isUseMaterialValueWhenRemovingPartialValue() const override
298 {
299 return m_is_use_material_value_when_removing_partial_value;
300 }
301
302 public:
303
304 AllEnvData* allEnvData() { return m_all_env_data.get(); }
305 ComponentItemSharedInfo* componentItemSharedInfo(Int32 level) const;
306 void syncVariablesReferences(bool check_resize);
307
308 void incrementTimestamp() { ++m_timestamp; }
309 void dumpInfos2(std::ostream& o);
310
311 const MeshHandle& meshHandle() const { return m_mesh_handle; }
312
313 void enableCellToAllEnvCellForRunCommand(bool is_enable, bool force_create=false) override
314 {
315 m_is_use_accelerator_envcell_container = is_enable;
316 if (force_create)
317 createAllCellToAllEnvCell();
318 }
319 bool isCellToAllEnvCellForRunCommand() const override { return m_is_use_accelerator_envcell_container; }
320
321 IMeshMaterialMngInternal* _internalApi() const override { return m_internal_api.get(); }
322
323 public:
324
326 Runner& runner() const { return m_runner_info->m_runner; }
327 RunQueue& runQueue() const { return m_runner_info->m_run_queue; }
328 Accelerator::RunQueuePool& asyncRunQueuePool() const { return m_runner_info->m_async_queue_pool; }
329 Real additionalCapacityRatio() const { return m_additional_capacity_ratio; }
331
332 private:
333
334 AllCellToAllEnvCellContainer* getAllCellToAllEnvCellContainer() const { return m_accelerator_envcell_container.get(); }
335 void createAllCellToAllEnvCell();
336
337 private:
338
340 using FullNameVariableMap= std::map<String,IMeshMaterialVariable*>;
342 using FullNameVariablePair = FullNameVariableMap::value_type;
343
344 using VariableToMaterialVariableMap = std::map<IVariable*,IMeshMaterialVariable*>;
345 using VariableToMaterialVariablePair = VariableToMaterialVariableMap::value_type;
346
347 private:
348
349 MeshHandle m_mesh_handle;
350 std::unique_ptr<InternalApi> m_internal_api;
351 IVariableMng* m_variable_mng = nullptr;
352 String m_name;
353 bool m_is_end_create = false;
354 bool m_is_verbose = false;
355 bool m_keep_values_after_change = true;
356 bool m_is_data_initialisation_with_zero = false;
357 bool m_is_mesh_modification_notified = false;
358 bool m_is_allocate_scalar_environment_variable_as_material = false;
359 bool m_is_use_material_value_when_removing_partial_value = false;
360 int m_modification_flags = 0;
361 Real m_additional_capacity_ratio = 0.05;
362
363 Mutex m_variable_lock;
364
365 std::unique_ptr<MeshMaterialModifierImpl> m_modifier;
366 UniqueArray<MeshMaterialInfo*> m_materials_info;
367 UniqueArray<IMeshMaterial*> m_materials;
368 UniqueArray<IMeshComponent*> m_materials_as_components;
369 UniqueArray<MeshMaterial*> m_true_materials;
370 UniqueArray<IMeshEnvironment*> m_environments;
371 UniqueArray<IMeshComponent*> m_environments_as_components;
372 UniqueArray<IMeshComponent*> m_components;
373 UniqueArray<MeshEnvironment*> m_true_environments;
375 UniqueArray<MeshBlock*> m_true_blocks;
377 UniqueArray<MeshMaterialVariableIndexer*> m_variables_indexer_to_destroy;
378
379 FullNameVariableMap m_full_name_variable_map;
380 VariableToMaterialVariableMap m_var_to_mat_var_map;
381
382 std::unique_ptr<Properties> m_properties;
383 std::unique_ptr<AllEnvData> m_all_env_data;
385 std::unique_ptr<IMeshMaterialVariableSynchronizer> m_all_cells_mat_env_synchronizer;
386 std::unique_ptr<IMeshMaterialVariableSynchronizer> m_all_cells_env_only_synchronizer;
387 Integer m_synchronize_variable_version = 1;
388 std::unique_ptr<MeshMaterialExchangeMng> m_exchange_mng;
389 IMeshMaterialVariableFactoryMng* m_variable_factory_mng = nullptr;
390 std::unique_ptr<ObserverPool> m_observer_pool;
391 String m_data_compressor_service_name;
392 MeshMaterialSynchronizer* m_mms = nullptr;
393
394 std::unique_ptr<RunnerInfo> m_runner_info;
395
397 std::unique_ptr<AllCellToAllEnvCellContainer> m_accelerator_envcell_container;
398 bool m_is_use_accelerator_envcell_container = false;
399
400 bool m_is_use_accelerator_for_constituent_item_vector = true;
401
402 private:
403
404 void _endUpdate();
405 IMeshMaterialVariable* _findVariableFullyQualified(const String& name);
406 MeshMaterialInfo* _findMaterialInfo(const String& name);
407 MeshEnvironment* _findEnvironment(const String& name);
408 MeshBlock* _findBlock(const String& name);
410 void _addVariableIndexer(MeshMaterialVariableIndexer* var_idx);
411 void _checkEndCreate();
412 void _addVariableUnlocked(IMeshMaterialVariable* var);
413 void _saveInfosInProperties();
414 void _checkCreateProperties();
415 void _onMeshDestroyed();
416 void _unregisterAllVariables();
417 void _addVariable(IMeshMaterialVariable* var);
418 void _removeVariable(IMeshMaterialVariable* var);
419 MeshMaterialModifierImpl* _modifier();
421 {
422 return m_variables_indexer;
423 }
425 {
426 return m_all_cells_mat_env_synchronizer.get();
427 }
429 {
430 return m_all_cells_env_only_synchronizer.get();
431 }
432 void _dumpStats();
433};
434
435/*---------------------------------------------------------------------------*/
436/*---------------------------------------------------------------------------*/
437
438} // End namespace Arcane::Materials
439
440/*---------------------------------------------------------------------------*/
441/*---------------------------------------------------------------------------*/
442
443#endif
Collection de RunQueue.
File d'exécution pour un accélérateur.
Gestionnaire d'exécution pour accélérateur.
Definition core/Runner.h:68
Tableau d'items de types quelconques.
Maille d'un maillage.
Definition Item.h:1205
Vue constante d'un tableau de type T.
Interface d'un fonctor avec argument mais sans valeur de retour.
Interface du gestionnaire de traces.
Interface du gestionnaire de variables.
Interface d'une variable.
Definition IVariable.h:56
Table de connectivité des 'Cell' vers leur(s) 'AllEnvCell' destinée à une utilisation sur accélérateu...
Vue sur une liste de mailles avec infos sur les milieux.
Informations sur les valeurs des milieux.
Definition AllEnvData.h:44
Interface d'un bloc d'un maillage.
API interne Arcane de 'IMeshMaterialMng'.
Interface du gestionnaire des matériaux et des milieux d'un maillage.
Interface du gestionnaire de fabrique de variables matériaux.
Interface du synchroniseur de variables matériaux.
Interface d'une variable matériau d'un maillage.
Informations pour la création d'un milieu.
Infos d'un matériau d'un maillage.
bool isUseAcceleratorForConstituentItemVector() const override
Indique si on utilise l'API accélérateur pour positionner les valeurs de ConstituentItemVectorImpl.
Real additionalCapacityRatio() const override
Ratio pour la capacité additionnelle à allouer lors du redimensionnement des variables.
RunQueue runQueue(Accelerator::eExecutionPolicy policy) const override
File d'exécution pour la politique policy.
ComponentItemSharedInfo * componentItemSharedInfo(Int32 level) const override
MeshMaterialModifierImpl * modifier() override
Implémentation du modificateur.
IMeshMaterialVariableSynchronizer * allCellsEnvOnlySynchronizer() override
Synchronizeur pour les variables uniquement milieux sur toutes les mailles.
void removeVariable(IMeshMaterialVariable *var) override
Supprime la variable var.
AllCellToAllEnvCellContainer * getAllCellToAllEnvCellContainer() const override
Renvoie la table de "connectivité" CellLocalId -> AllEnvCell destinée à être utilisée dans un RUNCOMM...
void createAllCellToAllEnvCell() override
Construit la table de "connectivité" CellLocalId -> AllEnvCell destinée à être utilisée dans un RUNCO...
void addVariable(IMeshMaterialVariable *var) override
Ajoute la variable var.
RunQueue & runQueue() const override
File d'exécution par défaut.
Accelerator::RunQueuePool & asyncRunQueuePool() const override
Liste de files asynchrones.
IMeshMaterialVariableSynchronizer * allCellsMatEnvSynchronizer() override
Synchronizeur pour les variables matériaux et milieux sur toutes les mailles.
ConstArrayView< MeshMaterialVariableIndexer * > variablesIndexer() override
Liste des infos pour indexer les variables matériaux.
Implémentation d'un gestion des matériaux.
bool isInMeshMaterialExchange() const override
Vrai si on est en train de faire un échange de maillage avec gestion des matériaux.
void removeEnvironmentToBlock(IMeshBlock *block, IMeshEnvironment *env) override
Supprime un milieu à un bloc existant.
IMeshMaterialVariableFactoryMng * variableFactoryMng() const override
Interface de la fabrique de variables.
String dataCompressorServiceName() const override
virtual Nom du service utilisé pour compresser les données
AllEnvCellVectorView view(const CellGroup &cells) final
Vue sur les mailles milieux correspondant au groupe cells.
Int64 m_timestamp
Compteur du nombre de modifications des matériaux.
void setDataCompressorServiceName(const String &name) override
void visitVariables(IFunctorWithArgumentT< IMeshMaterialVariable * > *functor) override
Applique le fonctor functor sur l'ensemble des variables matériaux.
void endCreate(bool is_continue) override
Indique qu'on a fini de créer les milieux.
IMeshBlock * createBlock(const MeshBlockBuildInfo &infos) override
Créé un bloc.
Integer synchronizeVariableVersion() const override
Version de l'implémentation pour la synchronisation des variables matériaux.
bool isKeepValuesAfterChange() const override
Indique si les valeurs des variables sont conservées entre les modifications.
ITraceMng * traceMng() override
Gestionnaire de traces.
FullNameVariableMap::value_type FullNameVariablePair
Paire de la liste des variables par nom complet.
Int64 timestamp() const override
Compteur du nombre de modifications de la liste des matériaux et des milieux.
IMesh * mesh() override
Maillage associé.
IMeshMaterialVariableSynchronizer * _allCellsEnvOnlySynchronizer() override
Synchronizeur pour les variables uniquement milieux sur toutes les mailles.
CellToAllEnvCellConverter cellToAllEnvCellConverter() override
Créée une instance pour convertir de 'Cell' en 'AllEnvCell'.
void addEnvironmentToBlock(IMeshBlock *block, IMeshEnvironment *env) override
Ajoute un milieu à un bloc existant.
void dumpInfos(std::ostream &o) override
Ecrit les infos des matériaux et milieux sur le flot o.
IMeshMaterialVariableSynchronizer * _allCellsMatEnvSynchronizer() override
Synchronizeur pour les variables matériaux et milieux sur toutes les mailles.
MeshMaterialInfo * registerMaterialInfo(const String &name) override
Enregistre les infos du matériau de nom name.
void setMeshModificationNotified(bool v) override
Indique si les milieux et matériaux suivent les changements de topologie dans le maillage.
ConstArrayView< IMeshComponent * > components() const override
Liste de tous les composants.
void setAllocateScalarEnvironmentVariableAsMaterial(bool v) override
Positionne l'option indiquant si les variables scalaires milieux sont allouées sur les matériaux.
ConstArrayView< IMeshMaterial * > materials() const override
Liste des matériaux.
IMeshEnvironment * createEnvironment(const MeshEnvironmentBuildInfo &infos) override
Création d'un milieu.
void recreateFromDump() override
Recréé les infos des matériaux et milieux à partir des infos de la protection.
void enableCellToAllEnvCellForRunCommand(bool is_enable, bool force_create=false) override
Active ou désactive la construction et la mise à jour de la table de "connectivité" CellLocalId -> Al...
int modificationFlags() const override
Flags pour paramêtrer les modifications.
void fillWithUsedVariables(Array< IMeshMaterialVariable * > &variables) override
Remplit le tableau variables avec la liste des variables matériaux utilisés.
ConstArrayView< IMeshComponent * > environmentsAsComponents() const override
Liste des milieux vus comme composants.
ConstArrayView< IMeshEnvironment * > environments() const override
Liste des milieux.
IMeshMaterialVariable * checkVariable(IVariable *global_var) override
Variable aux matériaux associé à la variable global global_var (nullptr si aucune)
void forceRecompute() override
Force le recalcul des informations des matériaux.
void _endUpdate()
Remise à jour des structures suite à une modification des mailles de matériaux ou de milieux.
void setDataInitialisationWithZero(bool v) override
Indique comment initialiser les nouvelles valeurs dans les mailles matériaux et milieux.
void setKeepValuesAfterChange(bool v) override
Positionne la sauvegarde des valeurs entre deux modifications des matériaux.
AllEnvCellVectorView view(CellVectorView cells) final
Vue sur les mailles milieux correspondant au groupe cells.
bool isMeshModificationNotified() const override
Indique si les milieux et matériaux suivent les changements de topologie dans le maillage.
IMeshMaterialMngInternal * _internalApi() const override
API interne à Arcane.
void checkMaterialsInCells(Integer max_print) override
Vérifie que les mailles des matériaux sont cohérentes entre les sous-domaines.
IMeshEnvironment * findEnvironment(const String &name, bool throw_exception=true) override
Retourne le milieux de nom name.
bool isDataInitialisationWithZero() const override
Indique comment initialiser les nouvelles valeurs dans les mailles matériaux et milieux.
Mutex * variableLock() override
Verrou utilisé pour le multi-threading.
void setSynchronizeVariableVersion(Integer version) override
Positionne la version de l'implémentation pour la synchronisation des variables matériaux.
bool synchronizeMaterialsInCells() override
Synchronise les mailles des matériaux.
std::map< String, IMeshMaterialVariable * > FullNameVariableMap
Type de la liste des variables par nom complet.
ConstArrayView< IMeshComponent * > materialsAsComponents() const override
Liste des matériaux vus comme composants.
IMeshMaterialVariable * findVariable(const String &name) override
Variable de nom name ou nullptr si aucune de ce nom existe.
void setUseMaterialValueWhenRemovingPartialValue(bool v) override
Indique si on utilise la valeur matériau ou milieu lorsqu'on transforme une maille partielle en maill...
void dumpCellInfos(Cell cell, std::ostream &o) override
Ecrit les infos de la maille cell sur le flot o.
std::unique_ptr< AllCellToAllEnvCellContainer > m_accelerator_envcell_container
Conteneur pour AllEnvCellToAllEnvCell pour accélerateur.
ConstArrayView< IMeshBlock * > blocks() const override
Liste des blocs.
void checkValid() override
Vérifie la validité des structures internes.
void syncVariablesReferences(bool check_resize)
Met à jour les références des variables.
MeshMaterial * _createMaterial(MeshEnvironment *env, MeshMaterialInfo *infos, const String &name)
Création d'un matériau.
AllEnvCellVectorView view(SmallSpan< const Int32 > cells_local_id) final
Vue sur les mailles milieux correspondant aux mailles de numéro locaux cells_local_id.
bool isAllocateScalarEnvironmentVariableAsMaterial() const override
Indique si les variables scalaires milieux sont allouées sur les matériaux.
String name() const override
Nom du gestionnaire.
IMeshBlock * findBlock(const String &name, bool throw_exception=true) override
Retourne le bloc de nom name.
void setModificationFlags(int v) override
Positionner les flags pour paramêtrer les modifications de matériaux/milieux.
Synchronisation de la liste des matériaux/milieux des entités.
Matériau d'un maillage.
Informations pour la création d'un bloc.
Bloc d'un maillage.
Definition MeshBlock.h:50
Handle sur un maillage.
Definition MeshHandle.h:47
Liste d'observateurs.
Liste de propriétés.
Definition Properties.h:64
Vue d'un tableau d'éléments de type T.
Definition Span.h:673
Chaîne de caractères unicode.
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
ItemGroupT< Cell > CellGroup
Groupe de mailles.
Definition ItemTypes.h:183
ItemVectorViewT< Cell > CellVectorView
Vue sur un vecteur de mailles.
Definition ItemTypes.h:304
eExecutionPolicy
Politique d'exécution pour un Runner.
Active toujours les traces dans les parties Arcane concernant les matériaux.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
double Real
Type représentant un réel.
std::int32_t Int32
Type entier signé sur 32 bits.