14#include "arcane/materials/internal/MeshMaterialMng.h"
16#include "arcane/utils/TraceAccessor.h"
17#include "arcane/utils/NotImplementedException.h"
18#include "arcane/utils/AutoDestroyUserData.h"
19#include "arcane/utils/IUserDataList.h"
20#include "arcane/utils/OStringStream.h"
21#include "arcane/utils/PlatformUtils.h"
22#include "arcane/utils/ValueConvert.h"
23#include "arcane/utils/CheckedConvert.h"
26#include "arcane/core/IMesh.h"
27#include "arcane/core/IItemFamily.h"
28#include "arcane/core/VariableTypes.h"
29#include "arcane/core/ItemPrinter.h"
30#include "arcane/core/IVariableMng.h"
31#include "arcane/core/Properties.h"
32#include "arcane/core/ObserverPool.h"
33#include "arcane/core/materials/IMeshMaterialVariableFactoryMng.h"
34#include "arcane/core/materials/IMeshMaterialVariable.h"
36#include "arcane/core/materials/internal/IMeshMaterialVariableInternal.h"
37#include "arcane/core/internal/IVariableMngInternal.h"
39#include "arcane/accelerator/core/IAcceleratorMng.h"
41#include "arcane/materials/MeshMaterialInfo.h"
42#include "arcane/materials/MeshEnvironmentBuildInfo.h"
43#include "arcane/materials/CellToAllEnvCellConverter.h"
44#include "arcane/materials/MeshMaterialExchangeMng.h"
45#include "arcane/materials/EnumeratorTracer.h"
46#include "arcane/materials/MeshMaterialVariableFactoryRegisterer.h"
47#include "arcane/materials/internal/AllEnvData.h"
48#include "arcane/materials/internal/MeshMaterialModifierImpl.h"
49#include "arcane/materials/internal/MeshMaterialSynchronizer.h"
50#include "arcane/materials/internal/MeshMaterialVariableSynchronizer.h"
51#include "arcane/materials/internal/ConstituentConnectivityList.h"
52#include "arcane/materials/internal/AllCellToAllEnvCellContainer.h"
86arcaneCreateMeshMaterialMng(
const MeshHandle& mesh_handle,
const String& name)
88 MeshMaterialMng* mmm =
new MeshMaterialMng(mesh_handle,name);
99MeshMaterialMng::RunnerInfo::
100RunnerInfo(Runner& runner)
104, m_sequential_run_queue(
makeQueue(m_sequential_runner))
106, m_multi_thread_run_queue(
makeQueue(m_multi_thread_runner))
113void MeshMaterialMng::RunnerInfo::
114initializeAsyncPool(Int32 nb_queue)
120 m_async_queue_pool.initialize(m_runner,nb_queue);
122 m_async_queue_pool.setAsync(
true);
128RunQueue MeshMaterialMng::RunnerInfo::
129runQueue(Accelerator::eExecutionPolicy policy)
const
131 if (policy == Accelerator::eExecutionPolicy::None)
133 if (policy == Accelerator::eExecutionPolicy::Sequential)
134 return m_sequential_run_queue;
135 if (policy == Accelerator::eExecutionPolicy::Thread)
136 return m_multi_thread_run_queue;
137 ARCANE_FATAL(
"Invalid value '{0}' for execution policy. Valid values are None, Sequential or Thread", policy);
147MeshMaterialMng(
const MeshHandle& mesh_handle,
const String& name)
149: TraceAccessor(mesh_handle.traceMng())
150, m_mesh_handle(mesh_handle)
151, m_internal_api(std::make_unique<InternalApi>(this))
152, m_variable_mng(mesh_handle.variableMng())
155 m_all_env_data = std::make_unique<AllEnvData>(
this);
156 m_exchange_mng = std::make_unique<MeshMaterialExchangeMng>(
this);
157 m_variable_factory_mng = arcaneCreateMeshMaterialVariableFactoryMng(
this);
158 m_observer_pool = std::make_unique<ObserverPool>();
159 m_observer_pool->addObserver(
this,&MeshMaterialMng::_onMeshDestroyed,mesh_handle.onDestroyObservable());
161 String s = platform::getEnvironmentVariable(
"ARCANE_ALLENVCELL_FOR_RUNCOMMAND");
163 m_is_use_accelerator_envcell_container =
true;
164 m_mms =
new MeshMaterialSynchronizer(
this);
177 delete m_variable_factory_mng;
178 m_exchange_mng.reset();
179 m_all_cells_env_only_synchronizer.reset();
180 m_all_cells_mat_env_synchronizer.reset();
181 m_all_env_data.reset();
182 m_properties.reset();
184 for( MeshMaterial* m : m_true_materials )
186 m_true_materials.clear();
188 for( MeshEnvironment* e : m_true_environments )
190 m_true_environments.clear();
192 for (IMeshBlock* b : m_true_blocks)
195 for (MeshMaterialInfo* mmi : m_materials_info)
198 for (MeshMaterialVariableIndexer* mvi : m_variables_indexer_to_destroy)
202 m_internal_api.reset();
204 m_accelerator_envcell_container.reset();
208 m_runner_info.reset();
217void MeshMaterialMng::
222 auto* x = MeshMaterialVariableFactoryRegisterer::firstRegisterer();
224 m_variable_factory_mng->registerFactory(x->createFactory());
225 x = x->nextRegisterer();
232 if (
auto v = Convert::Type<Real>::tryParseFromEnvironment(
"ARCANE_MATERIALMNG_USE_ACCELERATOR_FOR_CONSTITUENTITEMVECTOR",
true)){
233 m_is_use_accelerator_for_constituent_item_vector = (v.value()!=0);
239 if (TaskFactory::isActive())
240 m_is_use_accelerator_for_constituent_item_vector =
false;
241 info() <<
"Use accelerator API for 'ConstituentItemVectorImpl' = " << m_is_use_accelerator_for_constituent_item_vector;
246 IAcceleratorMng* acc_mng = m_variable_mng->_internalApi()->acceleratorMng();
249 Runner* default_runner = acc_mng->defaultRunner();
251 bool use_accelerator_runner =
true;
252 if (
auto v = Convert::Type<Int32>::tryParseFromEnvironment(
"ARCANE_MATERIALMNG_USE_QUEUE",
true))
253 use_accelerator_runner = (v.value()!=0);
254 if (use_accelerator_runner && default_runner)
255 runner = *default_runner;
258 if (!runner.isInitialized())
259 runner.initialize(Accelerator::eExecutionPolicy::Sequential);
260 m_runner_info = std::make_unique<RunnerInfo>(runner);
262 info() <<
"Use runner '" << this->runner().executionPolicy() <<
"' for MeshMaterialMng name=" << name()
263 <<
" async_queue_size=" << nb_queue;
264 m_runner_info->initializeAsyncPool(nb_queue);
271 RunQueue& q = runQueue();
273 q.setMemoryRessource(eMemoryRessource::Device);
278 int default_flags = 0;
284 int opt_flag_value = 0;
285 String env_name =
"ARCANE_MATERIAL_MODIFICATION_FLAGS";
286 String opt_flag_str = platform::getEnvironmentVariable(env_name);
287 if (!opt_flag_str.null()){
288 if (builtInGetValue(opt_flag_value,opt_flag_str)){
289 pwarning() <<
"Invalid value '" << opt_flag_str
290 <<
" 'for environment variable '" << env_name
292 opt_flag_value = default_flags;
296 opt_flag_value = default_flags;
298 m_modification_flags = opt_flag_value;
303 String env_name =
"ARCANE_MATSYNCHRONIZE_VERSION";
304 String env_value = platform::getEnvironmentVariable(env_name);
305 info() <<
"ENV_VALUE=" << env_value;
306 Integer version = m_synchronize_variable_version;
307 if (!env_value.null()){
308 if (builtInGetValue(version,env_value)){
309 pwarning() <<
"Invalid value '" << env_value
310 <<
" 'for environment variable '" << env_name
314 m_synchronize_variable_version = version;
316 info() <<
"Set material variable synchronize version to "
317 <<
"'" << m_synchronize_variable_version <<
"'";
322 String env_name =
"ARCANE_MATERIAL_DATA_COMPRESSOR_NAME";
323 String env_value = platform::getEnvironmentVariable(env_name);
324 if (!env_value.null()){
325 info() <<
"Use service '" << env_value <<
"' for material data compression";
326 m_data_compressor_service_name = env_value;
332 if (
auto v = Convert::Type<Real>::tryParseFromEnvironment(
"ARCANE_MATERIALMNG_ADDITIONAL_CAPACITY_RATIO",
true)){
334 m_additional_capacity_ratio = v.value();
335 info() <<
"Set additional capacity ratio to " << m_additional_capacity_ratio;
340 m_exchange_mng->build();
345 IItemEnumeratorTracer* item_tracer = IItemEnumeratorTracer::singleton();
347 info() <<
"Adding material enumerator tracing";
348 EnumeratorTracer::_setSingleton(
new EnumeratorTracer(traceMng(),item_tracer->perfCounterRef()));
355void MeshMaterialMng::
356_addVariableIndexer(MeshMaterialVariableIndexer* var_idx)
358 var_idx->setIndex(m_variables_indexer.size());
359 m_variables_indexer.add(var_idx);
370MeshMaterial* MeshMaterialMng::
371_createMaterial(MeshEnvironment* env,MeshMaterialInfo* infos,
const String& name)
374 if (infos->materialMng()!=
this)
375 ARCANE_FATAL(
"Invalid materialMng() for material info");
376 if (env->materialMng()!=
this)
378 Integer var_index = m_variables_indexer.size();
379 Int16 mat_id = CheckedConvert::toInt16(m_materials.size());
380 MeshMaterial* mat =
new MeshMaterial(infos,env,name,mat_id);
381 info() <<
"Create material name=" << name <<
"mat_id=" << mat_id <<
" var_index=" << var_index;
383 m_materials.add(mat);
384 m_materials_as_components.add(mat);
385 m_true_materials.add(mat);
387 _addVariableIndexer(mat->variableIndexer());
394MeshMaterialInfo* MeshMaterialMng::
395registerMaterialInfo(
const String& name)
399 MeshMaterialInfo* old_mmi = _findMaterialInfo(name);
401 ARCANE_FATAL(
"Un matériau de nom '{0}' est déjà enregistré",name);
403 MeshMaterialInfo* mmi =
new MeshMaterialInfo(
this,name);
404 m_materials_info.add(mmi);
417IMeshEnvironment* MeshMaterialMng::
418createEnvironment(
const MeshEnvironmentBuildInfo& infos)
421 Int16 env_index = CheckedConvert::toInt16(m_environments.size());
423 const String& env_name = infos.name();
424 MeshEnvironment* old_me = _findEnvironment(env_name);
426 ARCANE_FATAL(
"Un milieu de nom '{0}' est déjà enregistré",env_name);
428 info() <<
"Creating environment name=" << env_name <<
" index=" << env_index;
430 MeshEnvironment* me =
new MeshEnvironment(
this,env_name,env_index);
432 m_true_environments.add(me);
433 m_environments.add(me);
434 m_environments_as_components.add(me);
437 Integer nb_mat = infos.materials().size();
438 ConstArrayView<MeshEnvironmentBuildInfo::MatInfo> mat_build_infos = infos.materials();
439 for( Integer i=0; i<nb_mat; ++i ){
440 const MeshEnvironmentBuildInfo::MatInfo& buildinfo = mat_build_infos[i];
441 const String& mat_name = buildinfo.m_name;
442 String new_mat_name = env_name +
"_" + mat_name;
443 MeshMaterialInfo* mat_info = _findMaterialInfo(mat_name);
445 ARCANE_FATAL(
"Aucun matériau de nom '{0}' n'est défini",mat_name);
447 MeshMaterial* mm = _createMaterial(me,mat_info,new_mat_name);
449 mat_info->_addEnvironment(env_name);
455 MeshMaterialVariableIndexer* var_idx =
nullptr;
457 var_idx = me->materials()[0]->_internalApi()->variableIndexer();
460 var_idx =
new MeshMaterialVariableIndexer(traceMng(),me->name());
461 _addVariableIndexer(var_idx);
462 m_variables_indexer_to_destroy.add(var_idx);
464 me->setVariableIndexer(var_idx);
472IMeshBlock* MeshMaterialMng::
473createBlock(
const MeshBlockBuildInfo& infos)
477 Int32 block_index = m_blocks.size();
479 const String& name = infos.name();
480 const MeshBlock* old_mb = _findBlock(name);
482 ARCANE_FATAL(
"Un bloc de nom '{0}' est déjà enregistré",name);
484 info() <<
"Creating block name=" << name <<
" index=" << block_index
485 <<
" nb_env=" << infos.environments().size();
486 Integer nb_env = infos.environments().size();
487 for( Integer i=0; i<nb_env; ++i )
488 info() <<
" Adding environment name=" << infos.environments()[i]->name() <<
" to block";
491 MeshBlock* mb =
new MeshBlock(
this,block_index,infos);
493 m_true_blocks.add(mb);
502void MeshMaterialMng::
503addEnvironmentToBlock(IMeshBlock* block,IMeshEnvironment* env)
506 mb->addEnvironment(env);
512void MeshMaterialMng::
513removeEnvironmentToBlock(IMeshBlock* block,IMeshEnvironment* env)
516 mb->removeEnvironment(env);
522void MeshMaterialMng::
523endCreate(
bool is_continue)
528 _saveInfosInProperties();
530 info() <<
"END CREATE MATERIAL_MNG is_continue=" << is_continue;
532 m_modifier = std::make_unique<MeshMaterialModifierImpl>(
this);
533 m_modifier->initOptimizationFlags();
535 m_all_env_data->endCreate(is_continue);
537 auto synchronizer = mesh()->cellFamily()->allItemsSynchronizer();
538 m_all_cells_mat_env_synchronizer = std::make_unique<MeshMaterialVariableSynchronizer>(
this,synchronizer,MatVarSpace::MaterialAndEnvironment);
539 m_all_cells_env_only_synchronizer = std::make_unique<MeshMaterialVariableSynchronizer>(
this,synchronizer,MatVarSpace::Environment);
543 Integer nb_component = m_environments_as_components.size() + m_materials_as_components.size();
544 m_components.reserve(nb_component);
545 m_components.addRange(m_environments_as_components);
546 m_components.addRange(m_materials_as_components);
551 for(
const auto& i : m_full_name_variable_map ){
552 IMeshMaterialVariable* mv = i.second;
553 info(4) <<
"BUILD FROM MANAGER name=" << mv->name() <<
" this=" <<
this;
554 mv->buildFromManager(is_continue);
558 m_is_end_create =
true;
566 for( IMeshEnvironment* env : m_environments ){
572 m_exchange_mng->registerFactory();
578void MeshMaterialMng::
579setModificationFlags(
int v)
582 m_modification_flags = v;
583 info() <<
"Setting ModificationFlags to v=" << v;
589void MeshMaterialMng::
590setAllocateScalarEnvironmentVariableAsMaterial(
bool v)
593 m_is_allocate_scalar_environment_variable_as_material = v;
594 info() <<
"Setting AllocateScalarEnvironmentVariableAsMaterial to v=" << v;
600void MeshMaterialMng::
601setDataCompressorServiceName(
const String& name)
603 m_data_compressor_service_name = name;
609MeshMaterialModifierImpl* MeshMaterialMng::
612 return m_modifier.get();
618MeshMaterialInfo* MeshMaterialMng::
619_findMaterialInfo(
const String& name)
621 for( MeshMaterialInfo* mmi : m_materials_info )
622 if (mmi->name()==name)
630IMeshEnvironment* MeshMaterialMng::
631findEnvironment(
const String& name,
bool throw_exception)
633 IMeshEnvironment* env = _findEnvironment(name);
644MeshEnvironment* MeshMaterialMng::
645_findEnvironment(
const String& name)
647 for( MeshEnvironment* env : m_true_environments )
648 if (env->name()==name)
656IMeshBlock* MeshMaterialMng::
657findBlock(
const String& name,
bool throw_exception)
659 IMeshBlock* block = _findBlock(name);
670MeshBlock* MeshMaterialMng::
671_findBlock(
const String& name)
673 for( MeshBlock* b : m_true_blocks )
682void MeshMaterialMng::
694void MeshMaterialMng::
697 m_all_env_data->forceRecompute(
true);
709void MeshMaterialMng::
710syncVariablesReferences(
bool check_resize)
712 for(
const auto& i : m_full_name_variable_map ){
713 IMeshMaterialVariable* mv = i.second;
714 info(4) <<
"SYNC REFERENCES FROM MANAGER name=" << mv->name();
715 mv->_internalApi()->syncReferences(check_resize);
722void MeshMaterialMng::
723visitVariables(IFunctorWithArgumentT<IMeshMaterialVariable*>* functor)
727 for(
const auto& i : m_full_name_variable_map ){
728 IMeshMaterialVariable* mv = i.second;
729 functor->executeFunctor(mv);
736void MeshMaterialMng::
739 const IItemFamily* cell_family = mesh()->cellFamily();
740 ItemGroup all_cells = cell_family->allItems();
741 ConstArrayView<Int16> nb_env_per_cell = m_all_env_data->componentConnectivityList()->cellsNbEnvironment();
743 AllEnvCell all_env_cell = *iallenvcell;
744 Integer cell_nb_env = all_env_cell.nbEnvironment();
745 Cell cell = all_env_cell.globalCell();
746 Int64 cell_uid = cell.uniqueId();
747 if (all_env_cell.level()!=LEVEL_ALLENVIRONMENT)
750 if (all_env_cell.globalCell()!=cell)
751 ARCANE_FATAL(
"Bad corresponding globalCell() in all_env_item");
752 if (cell_nb_env != nb_env_per_cell[cell.localId()])
753 ARCANE_FATAL(
"Bad value for nb_env direct='{0}' var='{1}'",
754 cell_nb_env, nb_env_per_cell[cell.localId()]);
755 for( Integer z=0; z<cell_nb_env; ++z ){
756 EnvCell ec = all_env_cell.cell(z);
757 Integer cell_nb_mat = ec.nbMaterial();
758 matimpl::ConstituentItemBase eii = ec.constituentItemBase();
759 if (all_env_cell.constituentItemBase()!=eii._superItemBase())
760 ARCANE_FATAL(
"Bad corresponding allEnvItem() in env_item uid={0}",cell_uid);
761 if (eii.globalItemBase()!=cell)
762 ARCANE_FATAL(
"Bad corresponding globalItem() in env_item");
763 if (eii.level()!=LEVEL_ENVIRONMENT)
764 ARCANE_FATAL(
"Bad level '{0}' for in env_item",eii.level());
767 if (cell_nb_env>1 && ec._varIndex().arrayIndex()==0)
768 ARCANE_FATAL(
"Global index for a partial cell env_item={0}",ec);
770 for( Integer k=0; k<cell_nb_mat; ++k ){
771 MatCell mc = ec.cell(k);
772 matimpl::ConstituentItemBase mci = mc.constituentItemBase();
773 if (eii!=mci._superItemBase())
774 ARCANE_FATAL(
"Bad corresponding env_item in mat_item k={0} mc={1}",k,mc);
775 if (mci.globalItemBase()!=cell)
776 ARCANE_FATAL(
"Bad corresponding globalItem() in mat_item");
777 if (mci.level()!=LEVEL_MATERIAL)
778 ARCANE_FATAL(
"Bad level '{0}' for in mat_item",mci.level());
781 if ((cell_nb_env>1 || cell_nb_mat>1) && mc._varIndex().arrayIndex()==0){
782 ARCANE_FATAL(
"Global index for a partial cell matitem={0} name={1} nb_mat={2} nb_env={3}",
783 mc,mc.material()->name(),cell_nb_mat,cell_nb_env);
789 for( IMeshEnvironment* env : m_environments ){
797IMeshMaterialVariable* MeshMaterialMng::
798findVariable(
const String& name)
800 IMeshMaterialVariable* v = _findVariableFullyQualified(name);
807 const IVariable* global_var = m_variable_mng->findMeshVariable(mesh(),name);
809 v = _findVariableFullyQualified(global_var->fullName());
820IMeshMaterialVariable* MeshMaterialMng::
821_findVariableFullyQualified(
const String& name)
823 auto i = m_full_name_variable_map.find(name);
824 if (i!=m_full_name_variable_map.end())
832IMeshMaterialVariable* MeshMaterialMng::
833checkVariable(IVariable* global_var)
835 auto i = m_var_to_mat_var_map.find(global_var);
836 if (i!=m_var_to_mat_var_map.end())
844void MeshMaterialMng::
845fillWithUsedVariables(Array<IMeshMaterialVariable*>& variables)
851 for(
const auto& i : m_full_name_variable_map ){
852 IMeshMaterialVariable* ivar = i.second;
853 if (ivar->globalVariable()->isUsed())
861void MeshMaterialMng::
862_addVariable(IMeshMaterialVariable* var)
865 IVariable* gvar = var->globalVariable();
866 info(4) <<
"MAT_ADD_VAR global_var=" << gvar <<
" var=" << var <<
" this=" <<
this;
867 m_var_to_mat_var_map.insert(std::make_pair(gvar,var));
868 m_full_name_variable_map.insert(std::make_pair(gvar->fullName(),var));
874void MeshMaterialMng::
875_removeVariable(IMeshMaterialVariable* var)
878 IVariable* gvar = var->globalVariable();
879 info(4) <<
"MAT:Remove variable global_var=" << gvar <<
" var=" << var;
880 m_var_to_mat_var_map.erase(gvar);
881 m_full_name_variable_map.erase(gvar->fullName());
887void MeshMaterialMng::
888dumpInfos(std::ostream& o)
890 Integer nb_mat = m_materials.size();
891 Integer nb_env = m_environments.size();
892 Integer nb_var_idx = m_variables_indexer.size();
893 o <<
"-- Infos sur les milieux et matériaux\n";
894 o <<
"-- Nb Materiaux: " << nb_mat <<
'\n';
895 o <<
"-- Nb Milieux: " << nb_env <<
'\n';
896 o <<
"-- Nb Variables partielles: " << nb_var_idx <<
'\n';
898 o <<
"-- Liste des matériaux\n";
899 for( IMeshMaterial* mat : m_materials ){
900 o <<
"-- Materiau name=" << mat->name() <<
'\n';
903 o <<
"-- Liste des milieux\n";
904 for( IMeshEnvironment* me : m_environments ){
905 ConstArrayView<IMeshMaterial*> env_materials = me->materials();
906 const MeshMaterialVariableIndexer* env_var_idx = me->_internalApi()->variableIndexer();
907 Integer nb_env_mat = env_materials.size();
908 o <<
"-- Milieu name=" << me->name()
909 <<
" nb_mat=" << nb_env_mat
910 <<
" nb_cell=" << me->cells().size()
911 <<
" var_idx = " << env_var_idx->index()
912 <<
" ids=" << env_var_idx->matvarIndexes()
914 for( IMeshMaterial* mm : env_materials ){
915 const MeshMaterialVariableIndexer* idx = mm->_internalApi()->variableIndexer();
916 o <<
"-- Materiau\n";
917 o <<
"-- name = " << mm->name() <<
"\n";
918 o <<
"-- nb_cell = " << mm->cells().size() <<
"\n";
919 o <<
"-- var_idx = " << idx->index() <<
"\n";
927void MeshMaterialMng::
928dumpInfos2(std::ostream& o)
930 const ConstituentConnectivityList& constituent_list = *m_all_env_data->componentConnectivityList();
931 ConstArrayView<Int16> nb_env_per_cell = constituent_list.cellsNbEnvironment();
932 Integer nb_mat = m_materials.size();
933 Integer nb_env = m_environments.size();
934 Integer nb_var_idx = m_variables_indexer.size();
935 o <<
"-- Material and Environment infos: nb_env=" << nb_env
936 <<
" nb_mat=" << nb_mat <<
" timestamp=" << m_timestamp
937 <<
" nb_var_idx=" << nb_var_idx
939 Integer nb_cell = mesh()->allCells().size();
943 if (nb_env_per_cell[icell.localId()] <= 1)
946 o <<
" nb_cell=" << nb_cell <<
" nb_pure_env=" << nb_pure_env
947 <<
" nb_partial=" << (nb_cell-nb_pure_env)
948 <<
" percent=" << (100*nb_pure_env)/nb_cell
952 o <<
"-- Liste des milieux\n";
953 for( MeshEnvironment* me : m_true_environments ){
954 ConstArrayView<IMeshMaterial*> env_materials = me->materials();
955 const MeshMaterialVariableIndexer* env_var_idx = me->variableIndexer();
956 const Int16 env_id = me->componentId();
957 Integer nb_env_mat = env_materials.size();
958 Integer nb_env_cell = me->cells().size();
962 if (constituent_list.cellNbMaterial(icell, env_id) <= 1)
967 nb_pure_mat = nb_env_cell;
968 o <<
"-- Env name=" << me->name()
969 <<
" nb_mat=" << nb_env_mat
970 <<
" var_idx=" << env_var_idx->index()
971 <<
" nb_cell=" << nb_env_cell
972 <<
" nb_pure_mat=" << nb_pure_mat;
974 o <<
" percent=" << (nb_pure_mat*100)/nb_env_cell;
976 for( Integer j=0; j<nb_env_mat; ++j ){
977 IMeshMaterial* mm = env_materials[j];
978 const MeshMaterialVariableIndexer* idx = mm->_internalApi()->variableIndexer();
979 o <<
"-- Mat name=" << mm->name()
980 <<
" nb_cell=" << mm->cells().size()
981 <<
" var_idx=" << idx->index()
990bool MeshMaterialMng::
991synchronizeMaterialsInCells()
993 return m_mms->synchronizeMaterialsInCells();
999void MeshMaterialMng::
1000checkMaterialsInCells(Integer max_print)
1002 m_mms->checkMaterialsInCells(max_print);
1008void MeshMaterialMng::
1009dumpCellInfos(Cell cell,std::ostream& o)
1011 CellToAllEnvCellConverter all_env_cell_converter(
this);
1012 AllEnvCell all_env_cell = all_env_cell_converter[cell];
1013 Cell global_cell = all_env_cell.globalCell();
1014 o <<
"Cell uid=" << ItemPrinter(global_cell) <<
'\n';
1016 o <<
"ENV name=" << (*ienvcell).environment()->name()
1017 <<
" component_idx=" << ComponentItemLocalId(ienvcell) <<
'\n';
1019 o <<
"MAT name=" << (*imatcell).material()->name()
1020 <<
" component_idx=" << ComponentItemLocalId(imatcell) <<
'\n';
1028CellToAllEnvCellConverter MeshMaterialMng::
1029cellToAllEnvCellConverter()
1031 return CellToAllEnvCellConverter(componentItemSharedInfo(LEVEL_ALLENVIRONMENT));
1037void MeshMaterialMng::
1040 if (m_is_end_create)
1041 ARCANE_FATAL(
"Invalid method call because endCreate() has already been called");
1047AllEnvCellVectorView MeshMaterialMng::
1048_view(SmallSpan<const Int32> local_ids)
1050 return AllEnvCellVectorView(local_ids.constSmallView(), componentItemSharedInfo(LEVEL_ALLENVIRONMENT));
1056class MeshMaterialMngFactory
1060 MeshMaterialMngFactory()
1062 IMeshMaterialMng::_internalSetFactory(
this);
1064 ~MeshMaterialMngFactory()
1066 IMeshMaterialMng::_internalSetFactory(
nullptr);
1071 static MeshMaterialMngFactory m_mesh_material_mng_factory;
1080getTrueReference(
const MeshHandle& mesh_handle,
bool is_create)
1085 const char* name =
"MeshMaterialMng_StdMat";
1092 IMeshMaterialMng* mm = arcaneCreateMeshMaterialMng(mesh_handle,
"StdMat");
1093 Ref<IMeshMaterialMng> mm_ref = makeRef(mm);
1094 udlist->
setData(name,
new UserDataType(
new Ref<IMeshMaterialMng>(mm_ref)));
1097 auto adud =
dynamic_cast<UserDataType*
>(ud);
1100 return *(adud->data());
1106bool MeshMaterialMng::
1107isInMeshMaterialExchange()
const
1109 return m_exchange_mng->isInMeshMaterialExchange();
1115void MeshMaterialMng::
1116_checkCreateProperties()
1120 m_properties = std::make_unique<Properties>(*(mesh()->properties()),String(
"MeshMaterialMng_")+name());
1127const Int32 SERIALIZE_VERSION = 1;
1129void MeshMaterialMng::
1130_saveInfosInProperties()
1132 _checkCreateProperties();
1135 m_properties->set(
"Version",SERIALIZE_VERSION);
1139 UniqueArray<String> material_info_names;
1140 for( MeshMaterialInfo* mat_info : m_materials_info ){
1141 material_info_names.add(mat_info->name());
1143 m_properties->set(
"MaterialInfoNames",material_info_names);
1145 UniqueArray<String> env_names;
1146 UniqueArray<Int32> env_nb_mat;
1147 UniqueArray<String> env_mat_names;
1149 IMeshEnvironment* env = *ienv;
1150 env_names.add(env->name());
1151 info(5) <<
"SAVE ENV_NAME name=" << env->name() <<
" nb_mat=" << env->nbMaterial();
1152 env_nb_mat.add(env->nbMaterial());
1154 const String& name = (*imat)->infos()->name();
1155 info(5) <<
"SAVE MAT_NAME name=" << name;
1156 env_mat_names.add(name);
1159 m_properties->set(
"EnvNames",env_names);
1160 m_properties->set(
"EnvNbMat",env_nb_mat);
1161 m_properties->set(
"EnvMatNames",env_mat_names);
1165 UniqueArray<String> block_names;
1166 UniqueArray<String> block_cell_group_names;
1167 UniqueArray<Int32> block_nb_env;
1168 UniqueArray<String> block_env_names;
1169 for( IMeshBlock* block : m_blocks ){
1170 block_names.add(block->name());
1171 block_cell_group_names.add(block->cells().name());
1172 block_nb_env.add(block->nbEnvironment());
1174 const String& name = (*ienv)->name();
1175 info(5) <<
"SAVE BLOCK ENV_NAME name=" << name;
1176 block_env_names.add(name);
1179 m_properties->set(
"BlockNames",block_names);
1180 m_properties->set(
"BlockCellGroupNames",block_cell_group_names);
1181 m_properties->set(
"BlockNbEnv",block_nb_env);
1182 m_properties->set(
"BlockEnvNames",block_env_names);
1188void MeshMaterialMng::
1191 if (m_is_end_create)
1194 _checkCreateProperties();
1196 info() <<
"Creating material infos from dump";
1199 Int32 v = m_properties->getInt32(
"Version");
1200 if (v!=SERIALIZE_VERSION)
1201 ARCANE_FATAL(
"Bad serializer version: trying to read from incompatible checkpoint v={0} expected={1}",
1202 v,SERIALIZE_VERSION);
1204 UniqueArray<String> material_info_names;
1205 m_properties->get(
"MaterialInfoNames",material_info_names);
1206 for(
const String& mat_name : material_info_names )
1207 this->registerMaterialInfo(mat_name);
1209 UniqueArray<String> env_names;
1210 UniqueArray<Int32> env_nb_mat;
1211 UniqueArray<String> env_mat_names;
1212 m_properties->get(
"EnvNames",env_names);
1213 m_properties->get(
"EnvNbMat",env_nb_mat);
1214 m_properties->get(
"EnvMatNames",env_mat_names);
1217 for( Integer ienv=0, nenv=env_names.size(); ienv<nenv; ++ienv ){
1218 Materials::MeshEnvironmentBuildInfo env_build(env_names[ienv]);
1219 Integer nb_mat = env_nb_mat[ienv];
1220 for( Integer imat=0; imat<nb_mat; ++imat ){
1221 env_build.addMaterial(env_mat_names[mat_index]);
1224 this->createEnvironment(env_build);
1229 UniqueArray<String> block_names;
1230 UniqueArray<String> block_cell_group_names;
1231 UniqueArray<String> block_env_names;
1232 UniqueArray<Int32> block_nb_env;
1233 m_properties->get(
"BlockNames",block_names);
1234 m_properties->get(
"BlockCellGroupNames",block_cell_group_names);
1235 m_properties->get(
"BlockNbEnv",block_nb_env);
1236 m_properties->get(
"BlockEnvNames",block_env_names);
1237 const IItemFamily* cell_family = mesh()->cellFamily();
1239 for( Integer i=0, n=block_names.size(); i<n; ++i ){
1240 String name = block_names[i];
1241 String cell_group_name = block_cell_group_names[i];
1242 CellGroup cells = cell_family->findGroup(cell_group_name);
1244 ARCANE_FATAL(
"Can not find cell group '{0}' for block creation",
1246 MeshBlockBuildInfo mbbi(name,cells);
1247 if (!block_nb_env.empty()){
1248 Integer nb_env = block_nb_env[i];
1249 for( Integer ienv=0; ienv<nb_env; ++ienv ){
1250 const String& name2 = block_env_names[block_env_index];
1252 IMeshEnvironment* env = findEnvironment(name2,
false);
1254 ARCANE_FATAL(
"Invalid environment name '{0}' for recreating blocks",name2);
1255 mbbi.addEnvironment(env);
1258 this->createBlock(mbbi);
1267void MeshMaterialMng::
1274 m_exchange_mng.reset();
1276 _unregisterAllVariables();
1282void MeshMaterialMng::
1283_unregisterAllVariables()
1288 UniqueArray<MeshMaterialVariableRef*> m_all_refs;
1290 for(
const auto& i : m_full_name_variable_map ){
1291 const IMeshMaterialVariable* var = i.second;
1293 for( MeshMaterialVariableRef::Enumerator iref(var); iref.hasNext(); ++iref ){
1294 MeshMaterialVariableRef* ref = *iref;
1295 m_all_refs.add(ref);
1299 for( MeshMaterialVariableRef* ref : m_all_refs )
1300 ref->unregisterVariable();
1306ComponentItemSharedInfo* MeshMaterialMng::
1307componentItemSharedInfo(Int32 level)
const
1309 ComponentItemInternalData* data = m_all_env_data->componentItemInternalData();
1310 ComponentItemSharedInfo* shared_info =
nullptr;
1311 if (level == LEVEL_MATERIAL)
1312 shared_info = data->matSharedInfo();
1313 else if (level == LEVEL_ENVIRONMENT)
1314 shared_info = data->envSharedInfo();
1315 else if (level==LEVEL_ALLENVIRONMENT)
1316 shared_info = data->allEnvSharedInfo();
1326void MeshMaterialMng::
1329 IEnumeratorTracer* tracer = IEnumeratorTracer::singleton();
1331 tracer->dumpStats();
1334 m_modifier->dumpStats();
1336 for (IMeshEnvironment* env : m_environments) {
1340 if (env->nbMaterial() > 1)
1341 env->_internalApi()->variableIndexer()->dumpStats();
1343 for (IMeshMaterial* mat : m_materials) {
1344 mat->_internalApi()->variableIndexer()->dumpStats();
1351void MeshMaterialMng::
1352createAllCellToAllEnvCell()
1354 if (!m_accelerator_envcell_container) {
1355 m_accelerator_envcell_container = std::make_unique<AllCellToAllEnvCellContainer>(
this);
1356 m_accelerator_envcell_container->initialize();
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Fonctions de gestion mémoire et des allocateurs.
UserData s'auto-détruisant une fois détaché.
Interface d'une liste qui gère des données utilisateurs.
virtual void setData(const String &name, IUserData *ud)=0
Positionne le user-data associé au nom name.
virtual IUserData * data(const String &name, bool allow_null=false) const =0
Donnée associée à name.
Interface pour une donnée utilisateur attachée à un autre objet.
Interface du gestionnaire des matériaux et des milieux d'un maillage.
IUserDataList * meshUserDataList() const
Données utilisateurs associées.
Référence à une instance.
ItemGroupT< Cell > CellGroup
Groupe de mailles.
RunQueue makeQueue(const Runner &runner)
Créé une file associée à runner.
eExecutionPolicy
Politique d'exécution pour un Runner.
@ Sequential
Politique d'exécution séquentielle.
@ Thread
Politique d'exécution multi-thread.
bool isAcceleratorPolicy(eExecutionPolicy exec_policy)
Indique si exec_policy correspond à un accélérateur.
Active toujours les traces dans les parties Arcane concernant les matériaux.
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Int32 Integer
Type représentant un entier.
@ Cell
Le maillage est AMR par maille.