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)
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);
375 ARCANE_FATAL(
"Invalid materialMng() for material info");
378 Integer var_index = m_variables_indexer.size();
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());
404 m_materials_info.add(mmi);
426 ARCANE_FATAL(
"Un milieu de nom '{0}' est déjà enregistré",env_name);
428 info() <<
"Creating environment name=" << env_name <<
" index=" << env_index;
432 m_true_environments.add(me);
433 m_environments.add(me);
434 m_environments_as_components.add(me);
438 for(
Integer i=0; i<nb_mat; ++i ){
440 const String& mat_name = buildinfo.m_name;
441 String new_mat_name = env_name +
"_" + mat_name;
444 ARCANE_FATAL(
"Aucun matériau de nom '{0}' n'est défini",mat_name);
448 mat_info->_addEnvironment(env_name);
456 var_idx = me->
materials()[0]->_internalApi()->variableIndexer();
460 _addVariableIndexer(var_idx);
461 m_variables_indexer_to_destroy.add(var_idx);
463 me->setVariableIndexer(var_idx);
476 Int32 block_index = m_blocks.size();
483 info() <<
"Creating block name=" <<
name <<
" index=" << block_index
486 for(
Integer i=0; i<nb_env; ++i )
487 info() <<
" Adding environment name=" << infos.
environments()[i]->name() <<
" to block";
492 m_true_blocks.add(mb);
501void MeshMaterialMng::
511void MeshMaterialMng::
521void MeshMaterialMng::
522endCreate(
bool is_continue)
527 _saveInfosInProperties();
529 info() <<
"END CREATE MATERIAL_MNG is_continue=" << is_continue;
531 m_modifier = std::make_unique<MeshMaterialModifierImpl>(
this);
532 m_modifier->initOptimizationFlags();
534 m_all_env_data->endCreate(is_continue);
536 auto synchronizer =
mesh()->cellFamily()->allItemsSynchronizer();
538 m_all_cells_env_only_synchronizer = std::make_unique<MeshMaterialVariableSynchronizer>(
this,synchronizer,
MatVarSpace::Environment);
542 Integer nb_component = m_environments_as_components.size() + m_materials_as_components.size();
543 m_components.reserve(nb_component);
544 m_components.addRange(m_environments_as_components);
545 m_components.addRange(m_materials_as_components);
550 for(
const auto& i : m_full_name_variable_map ){
552 info(4) <<
"BUILD FROM MANAGER name=" << mv->
name() <<
" this=" <<
this;
557 m_is_end_create =
true;
571 m_exchange_mng->registerFactory();
577void MeshMaterialMng::
578setModificationFlags(
int v)
581 m_modification_flags = v;
582 info() <<
"Setting ModificationFlags to v=" << v;
588void MeshMaterialMng::
589setAllocateScalarEnvironmentVariableAsMaterial(
bool v)
592 m_is_allocate_scalar_environment_variable_as_material = v;
593 info() <<
"Setting AllocateScalarEnvironmentVariableAsMaterial to v=" << v;
599void MeshMaterialMng::
600setDataCompressorServiceName(
const String&
name)
602 m_data_compressor_service_name =
name;
611 return m_modifier.get();
618_findMaterialInfo(
const String& name)
621 if (mmi->name()==name)
630findEnvironment(
const String&
name,
bool throw_exception)
644_findEnvironment(
const String& name)
647 if (env->name()==name)
656findBlock(
const String&
name,
bool throw_exception)
670_findBlock(
const String& name)
681void MeshMaterialMng::
693void MeshMaterialMng::
696 m_all_env_data->forceRecompute(
true);
708void MeshMaterialMng::
709syncVariablesReferences(
bool check_resize)
711 for(
const auto& i : m_full_name_variable_map ){
713 info(4) <<
"SYNC REFERENCES FROM MANAGER name=" << mv->
name();
721void MeshMaterialMng::
726 for(
const auto& i : m_full_name_variable_map ){
728 functor->executeFunctor(mv);
735void MeshMaterialMng::
740 ConstArrayView<Int16> nb_env_per_cell = m_all_env_data->componentConnectivityList()->cellsNbEnvironment();
746 if (all_env_cell.
level()!=LEVEL_ALLENVIRONMENT)
750 ARCANE_FATAL(
"Bad corresponding globalCell() in all_env_item");
751 if (cell_nb_env != nb_env_per_cell[cell.
localId()])
752 ARCANE_FATAL(
"Bad value for nb_env direct='{0}' var='{1}'",
753 cell_nb_env, nb_env_per_cell[cell.
localId()]);
754 for(
Integer z=0; z<cell_nb_env; ++z ){
756 Integer cell_nb_mat = ec.nbMaterial();
759 ARCANE_FATAL(
"Bad corresponding allEnvItem() in env_item uid={0}",cell_uid);
761 ARCANE_FATAL(
"Bad corresponding globalItem() in env_item");
762 if (eii.level()!=LEVEL_ENVIRONMENT)
763 ARCANE_FATAL(
"Bad level '{0}' for in env_item",eii.level());
767 ARCANE_FATAL(
"Global index for a partial cell env_item={0}",ec);
769 for(
Integer k=0; k<cell_nb_mat; ++k ){
773 ARCANE_FATAL(
"Bad corresponding env_item in mat_item k={0} mc={1}",k,mc);
775 ARCANE_FATAL(
"Bad corresponding globalItem() in mat_item");
776 if (mci.level()!=LEVEL_MATERIAL)
777 ARCANE_FATAL(
"Bad level '{0}' for in mat_item",mci.level());
781 ARCANE_FATAL(
"Global index for a partial cell matitem={0} name={1} nb_mat={2} nb_env={3}",
808 v = _findVariableFullyQualified(global_var->
fullName());
820_findVariableFullyQualified(
const String& name)
822 auto i = m_full_name_variable_map.find(name);
823 if (i!=m_full_name_variable_map.end())
834 auto i = m_var_to_mat_var_map.find(global_var);
835 if (i!=m_var_to_mat_var_map.end())
843void MeshMaterialMng::
850 for(
const auto& i : m_full_name_variable_map ){
860void MeshMaterialMng::
865 info(4) <<
"MAT_ADD_VAR global_var=" << gvar <<
" var=" << var <<
" this=" <<
this;
866 m_var_to_mat_var_map.insert(std::make_pair(gvar,var));
867 m_full_name_variable_map.insert(std::make_pair(gvar->
fullName(),var));
873void MeshMaterialMng::
878 info(4) <<
"MAT:Remove variable global_var=" << gvar <<
" var=" << var;
879 m_var_to_mat_var_map.erase(gvar);
880 m_full_name_variable_map.erase(gvar->
fullName());
886void MeshMaterialMng::
887dumpInfos(std::ostream& o)
889 Integer nb_mat = m_materials.size();
890 Integer nb_env = m_environments.size();
891 Integer nb_var_idx = m_variables_indexer.size();
892 o <<
"-- Infos sur les milieux et matériaux\n";
893 o <<
"-- Nb Materiaux: " << nb_mat <<
'\n';
894 o <<
"-- Nb Milieux: " << nb_env <<
'\n';
895 o <<
"-- Nb Variables partielles: " << nb_var_idx <<
'\n';
897 o <<
"-- Liste des matériaux\n";
899 o <<
"-- Materiau name=" << mat->name() <<
'\n';
902 o <<
"-- Liste des milieux\n";
907 o <<
"-- Milieu name=" << me->name()
908 <<
" nb_mat=" << nb_env_mat
909 <<
" nb_cell=" << me->cells().size()
910 <<
" var_idx = " << env_var_idx->index()
911 <<
" ids=" << env_var_idx->matvarIndexes()
915 o <<
"-- Materiau\n";
916 o <<
"-- name = " << mm->
name() <<
"\n";
917 o <<
"-- nb_cell = " << mm->cells().size() <<
"\n";
918 o <<
"-- var_idx = " << idx->index() <<
"\n";
926void MeshMaterialMng::
927dumpInfos2(std::ostream& o)
931 Integer nb_mat = m_materials.size();
932 Integer nb_env = m_environments.size();
933 Integer nb_var_idx = m_variables_indexer.size();
934 o <<
"-- Material and Environment infos: nb_env=" << nb_env
935 <<
" nb_mat=" << nb_mat <<
" timestamp=" << m_timestamp
936 <<
" nb_var_idx=" << nb_var_idx
942 if (nb_env_per_cell[icell.localId()] <= 1)
945 o <<
" nb_cell=" << nb_cell <<
" nb_pure_env=" << nb_pure_env
946 <<
" nb_partial=" << (nb_cell-nb_pure_env)
947 <<
" percent=" << (100*nb_pure_env)/nb_cell
951 o <<
"-- Liste des milieux\n";
952 for( MeshEnvironment* me : m_true_environments ){
953 ConstArrayView<IMeshMaterial*> env_materials = me->materials();
954 const MeshMaterialVariableIndexer* env_var_idx = me->variableIndexer();
955 const Int16 env_id = me->componentId();
956 Integer nb_env_mat = env_materials.size();
957 Integer nb_env_cell = me->cells().size();
958 Integer nb_pure_mat = 0;
966 nb_pure_mat = nb_env_cell;
967 o <<
"-- Env name=" << me->name()
968 <<
" nb_mat=" << nb_env_mat
969 <<
" var_idx=" << env_var_idx->index()
970 <<
" nb_cell=" << nb_env_cell
971 <<
" nb_pure_mat=" << nb_pure_mat;
973 o <<
" percent=" << (nb_pure_mat*100)/nb_env_cell;
975 for( Integer j=0; j<nb_env_mat; ++j ){
976 IMeshMaterial* mm = env_materials[j];
977 const MeshMaterialVariableIndexer* idx = mm->_internalApi()->variableIndexer();
978 o <<
"-- Mat name=" << mm->name()
979 <<
" nb_cell=" << mm->cells().size()
980 <<
" var_idx=" << idx->index()
989bool MeshMaterialMng::
990synchronizeMaterialsInCells()
992 return m_mms->synchronizeMaterialsInCells();
998void MeshMaterialMng::
999checkMaterialsInCells(
Integer max_print)
1001 m_mms->checkMaterialsInCells(max_print);
1007void MeshMaterialMng::
1008dumpCellInfos(
Cell cell,std::ostream& o)
1011 AllEnvCell all_env_cell = all_env_cell_converter[cell];
1013 o <<
"Cell uid=" <<
ItemPrinter(global_cell) <<
'\n';
1015 o <<
"ENV name=" << (*ienvcell).environment()->name()
1016 <<
" component_idx=" << ComponentItemLocalId(ienvcell) <<
'\n';
1018 o <<
"MAT name=" << (*imatcell).material()->name()
1019 <<
" component_idx=" << ComponentItemLocalId(imatcell) <<
'\n';
1028cellToAllEnvCellConverter()
1036void MeshMaterialMng::
1039 if (m_is_end_create)
1040 ARCANE_FATAL(
"Invalid method call because endCreate() has already been called");
1055class MeshMaterialMngFactory
1059 MeshMaterialMngFactory()
1063 ~MeshMaterialMngFactory()
1070 static MeshMaterialMngFactory m_mesh_material_mng_factory;
1079getTrueReference(
const MeshHandle& mesh_handle,
bool is_create)
1084 const char* name =
"MeshMaterialMng_StdMat";
1091 IMeshMaterialMng* mm = arcaneCreateMeshMaterialMng(mesh_handle,
"StdMat");
1092 Ref<IMeshMaterialMng> mm_ref = makeRef(mm);
1093 udlist->
setData(name,
new UserDataType(
new Ref<IMeshMaterialMng>(mm_ref)));
1096 auto adud =
dynamic_cast<UserDataType*
>(ud);
1099 return *(adud->data());
1105bool MeshMaterialMng::
1106isInMeshMaterialExchange()
const
1108 return m_exchange_mng->isInMeshMaterialExchange();
1114void MeshMaterialMng::
1115_checkCreateProperties()
1119 m_properties = std::make_unique<Properties>(*(
mesh()->properties()),
String(
"MeshMaterialMng_")+name());
1126const Int32 SERIALIZE_VERSION = 1;
1128void MeshMaterialMng::
1129_saveInfosInProperties()
1131 _checkCreateProperties();
1134 m_properties->set(
"Version",SERIALIZE_VERSION);
1138 UniqueArray<String> material_info_names;
1139 for( MeshMaterialInfo* mat_info : m_materials_info ){
1140 material_info_names.add(mat_info->name());
1142 m_properties->set(
"MaterialInfoNames",material_info_names);
1144 UniqueArray<String> env_names;
1145 UniqueArray<Int32> env_nb_mat;
1146 UniqueArray<String> env_mat_names;
1148 IMeshEnvironment* env = *ienv;
1149 env_names.add(env->name());
1150 info(5) <<
"SAVE ENV_NAME name=" << env->name() <<
" nb_mat=" << env->nbMaterial();
1151 env_nb_mat.add(env->nbMaterial());
1153 const String& name = (*imat)->infos()->name();
1154 info(5) <<
"SAVE MAT_NAME name=" << name;
1155 env_mat_names.add(name);
1158 m_properties->set(
"EnvNames",env_names);
1159 m_properties->set(
"EnvNbMat",env_nb_mat);
1160 m_properties->set(
"EnvMatNames",env_mat_names);
1164 UniqueArray<String> block_names;
1165 UniqueArray<String> block_cell_group_names;
1166 UniqueArray<Int32> block_nb_env;
1167 UniqueArray<String> block_env_names;
1168 for( IMeshBlock* block : m_blocks ){
1169 block_names.add(block->name());
1170 block_cell_group_names.add(block->cells().name());
1171 block_nb_env.add(block->nbEnvironment());
1173 const String& name = (*ienv)->name();
1174 info(5) <<
"SAVE BLOCK ENV_NAME name=" << name;
1175 block_env_names.add(name);
1178 m_properties->set(
"BlockNames",block_names);
1179 m_properties->set(
"BlockCellGroupNames",block_cell_group_names);
1180 m_properties->set(
"BlockNbEnv",block_nb_env);
1181 m_properties->set(
"BlockEnvNames",block_env_names);
1187void MeshMaterialMng::
1190 if (m_is_end_create)
1193 _checkCreateProperties();
1195 info() <<
"Creating material infos from dump";
1198 Int32 v = m_properties->getInt32(
"Version");
1199 if (v!=SERIALIZE_VERSION)
1200 ARCANE_FATAL(
"Bad serializer version: trying to read from incompatible checkpoint v={0} expected={1}",
1201 v,SERIALIZE_VERSION);
1204 m_properties->get(
"MaterialInfoNames",material_info_names);
1205 for(
const String& mat_name : material_info_names )
1211 m_properties->get(
"EnvNames",env_names);
1212 m_properties->get(
"EnvNbMat",env_nb_mat);
1213 m_properties->get(
"EnvMatNames",env_mat_names);
1216 for(
Integer ienv=0, nenv=env_names.
size(); ienv<nenv; ++ienv ){
1218 Integer nb_mat = env_nb_mat[ienv];
1219 for(
Integer imat=0; imat<nb_mat; ++imat ){
1232 m_properties->get(
"BlockNames",block_names);
1233 m_properties->get(
"BlockCellGroupNames",block_cell_group_names);
1234 m_properties->get(
"BlockNbEnv",block_nb_env);
1235 m_properties->get(
"BlockEnvNames",block_env_names);
1238 for(
Integer i=0, n=block_names.
size(); i<n; ++i ){
1240 String cell_group_name = block_cell_group_names[i];
1243 ARCANE_FATAL(
"Can not find cell group '{0}' for block creation",
1246 if (!block_nb_env.
empty()){
1247 Integer nb_env = block_nb_env[i];
1248 for(
Integer ienv=0; ienv<nb_env; ++ienv ){
1249 const String& name2 = block_env_names[block_env_index];
1253 ARCANE_FATAL(
"Invalid environment name '{0}' for recreating blocks",name2);
1266void MeshMaterialMng::
1273 m_exchange_mng.reset();
1275 _unregisterAllVariables();
1281void MeshMaterialMng::
1282_unregisterAllVariables()
1289 for(
const auto& i : m_full_name_variable_map ){
1294 m_all_refs.
add(ref);
1298 for( MeshMaterialVariableRef* ref : m_all_refs )
1299 ref->unregisterVariable();
1305ComponentItemSharedInfo* MeshMaterialMng::
1306componentItemSharedInfo(Int32 level)
const
1308 ComponentItemInternalData* data = m_all_env_data->componentItemInternalData();
1309 ComponentItemSharedInfo* shared_info =
nullptr;
1310 if (level == LEVEL_MATERIAL)
1311 shared_info = data->matSharedInfo();
1312 else if (level == LEVEL_ENVIRONMENT)
1313 shared_info = data->envSharedInfo();
1314 else if (level==LEVEL_ALLENVIRONMENT)
1315 shared_info = data->allEnvSharedInfo();
1325void MeshMaterialMng::
1328 IEnumeratorTracer* tracer = IEnumeratorTracer::singleton();
1330 tracer->dumpStats();
1333 m_modifier->dumpStats();
1335 for (IMeshEnvironment* env : m_environments) {
1339 if (env->nbMaterial() > 1)
1340 env->_internalApi()->variableIndexer()->dumpStats();
1342 for (IMeshMaterial* mat : m_materials) {
1343 mat->_internalApi()->variableIndexer()->dumpStats();
1350void MeshMaterialMng::
1351createAllCellToAllEnvCell()
1353 if (!m_accelerator_envcell_container) {
1354 m_accelerator_envcell_container = std::make_unique<AllCellToAllEnvCellContainer>(
this);
1355 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.
Integer size() const
Nombre d'éléments du vecteur.
bool empty() const
Capacité (nombre d'éléments alloués) du vecteur.
Tableau d'items de types quelconques.
void clear()
Supprime les éléments du tableau.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
UserData s'auto-détruisant une fois détaché.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Interface d'un fonctor avec argument mais sans valeur de retour.
Interface d'une famille d'entités.
virtual ItemGroup findGroup(const String &name) const =0
Recherche un groupe.
virtual ItemGroup allItems() const =0
Groupe de toutes les entités.
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 d'une variable.
virtual String fullName() const =0
Nom complet de la variable (avec le préfixe de la famille)
virtual bool isUsed() const =0
Etat d'utilisation de la variable.
Groupe d'entités de maillage.
ItemVectorView view() const
Vue sur les entités du groupe.
bool null() const
true is le groupe est le groupe nul
Classe utilitaire pour imprimer les infos sur une entité.
Int32ConstArrayView localIds() const
Tableau des numéros locaux des entités.
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Vue sur une liste de mailles avec infos sur les milieux.
Maille arcane avec info matériaux et milieux.
__host__ __device__ Int32 nbEnvironment() const
Nombre de milieux présents dans la maille.
EnvCell cell(Int32 i) const
i-ème maille milieu
Conversion de 'Cell' en 'AllEnvCell'.
Gestion des listes de connectivité des constituants.
Int16 cellNbMaterial(CellLocalId cell_id, Int16 env_id)
Nombre de matériaux de la maille cell_id pour le milieu d'indice env_id.
Cell globalCell() const
Maille globale.
__host__ __device__ Int32 level() const
Niveau hiérarchique de l'entité
__host__ __device__ MatVarIndex _varIndex() const
Maille arcane d'un milieu.
__host__ __device__ MatCell cell(Integer i) const
i-ème maille matériau de cette maille
Interface d'un bloc d'un maillage.
virtual String name() const =0
Nom du composant.
Interface d'un milieu d'un maillage.
Interface du gestionnaire des matériaux et des milieux d'un maillage.
static void _internalSetFactory(IFactory *f)
Interface du gestionnaire de fabrique de variables matériaux.
virtual void syncReferences(bool check_resize)=0
Synchronise les références.
Interface d'une variable matériau d'un maillage.
virtual IVariable * globalVariable() const =0
Variable globale sur le maillage associée.
virtual String name() const =0
Nom de la variable.
virtual void buildFromManager(bool is_continue)=0
Construit les infos de la variable. A usage interne à Arcane.
Interface d'un matériau d'un maillage.
Représente un matériau d'une maille multi-matériau.
IMeshMaterial * material() const
Materiau associé
constexpr __host__ __device__ Int32 arrayIndex() const
Retourne l'indice du tableau de valeur dans la liste des variables.
Informations pour la création d'un milieu.
void addMaterial(const String &name)
Ajoute le matériau de nom name au milieu.
ConstArrayView< MatInfo > materials() const
const String & name() const
Nom du milieu.
void build()
Fonctions publiques mais réservées au IMeshMaterialMng.
ConstArrayView< IMeshMaterial * > materials() override
Liste des matériaux de ce milieu.
IMeshMaterialMng * materialMng() override
Gestionnaire associé.
String name() const override
Nom du composant.
Infos d'un matériau d'un maillage.
IMeshMaterialMng * materialMng()
Gestionnaire associé.
Implémentation d'un gestion des matériaux.
AllEnvCellVectorView view(const CellGroup &cells) final
Vue sur les mailles milieux correspondant au groupe cells.
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.
ITraceMng * traceMng() override
Gestionnaire de traces.
IMesh * mesh() override
Maillage associé.
MeshMaterialInfo * registerMaterialInfo(const String &name) override
Enregistre les infos du matériau de nom name.
IMeshEnvironment * createEnvironment(const MeshEnvironmentBuildInfo &infos) override
Création d'un milieu.
void _endUpdate()
Remise à jour des structures suite à une modification des mailles de matériaux ou de milieux.
IMeshEnvironment * findEnvironment(const String &name, bool throw_exception=true) override
Retourne le milieux de nom name.
MeshMaterial * _createMaterial(MeshEnvironment *env, MeshMaterialInfo *infos, const String &name)
Création d'un matériau.
String name() const override
Nom du gestionnaire.
Indexer pour les variables materiaux.
const String & name() const
Nom de l'indexeur.
Classe de base des références aux variables matériaux.
void build()
Fonctions publiques mais réservées au IMeshMaterialMng.
Informations génériques sur une entité d'un constituant.
__host__ __device__ matimpl::ConstituentItemBase _superItemBase() const
Composant supérieur (0 si aucun)
impl::ItemBase globalItemBase() const
Entité globale correspondante.
Informations pour la création d'un bloc.
ConstArrayView< IMeshEnvironment * > environments() const
Liste des milieux du bloc.
void addEnvironment(IMeshEnvironment *env)
Ajoute le milieu env au bloc.
const String & name() const
Nom du bloc.
void removeEnvironment(IMeshEnvironment *env)
Supprime le milieu env au bloc.
void build()
Fonctions publiques mais réservées au IMeshMaterialMng.
void addEnvironment(IMeshEnvironment *env)
Ajoute le milieu env au bloc.
IUserDataList * meshUserDataList() const
Données utilisateurs associées.
Référence à une instance.
Vue d'un tableau d'éléments de type T.
constexpr ConstArrayView< value_type > constSmallView() const
Vue constante sur cette vue.
Chaîne de caractères unicode.
TraceMessage info() const
Flot pour un message d'information.
Vecteur 1D de données avec sémantique par valeur (style STL).
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.
Int16 toInt16(Int64 v)
Converti un Int64 en un Int16.
Active toujours les traces dans les parties Arcane concernant les matériaux.
@ Environment
Variable ayant des valeurs uniquement sur les milieux.
@ MaterialAndEnvironment
Variable ayant des valeurs sur les milieux et matériaux.
bool arcaneIsCheck()
Vrai si on est en mode vérification.
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
std::int16_t Int16
Type entier signé sur 16 bits.
std::int32_t Int32
Type entier signé sur 32 bits.