MeshMaterialBackup.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MeshMaterialBackup.cc                                       (C) 2000-2023 */
/*                                                                           */
/* Backup/restoration of material and environment values.                    */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/materials/MeshMaterialBackup.h"
 
#include "arcane/utils/IDataCompressor.h"
 
#include "arcane/core/IVariable.h"
#include "arcane/core/IData.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/ServiceBuilder.h"
#include "arcane/core/internal/IDataInternal.h"
#include "arcane/core/materials/IMeshMaterialMng.h"
#include "arcane/core/materials/IMeshMaterialVariable.h"
#include "arcane/core/materials/MatItemEnumerator.h"
#include "arcane/core/materials/internal/IMeshMaterialVariableInternal.h"
#include "arcane/core/materials/internal/IMeshMaterialMngInternal.h"
 
#include "arcane/materials/internal/MeshMaterialMng.h"
#include "arcane/materials/internal/MeshMaterialVariableIndexer.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Materials
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
struct MeshMaterialBackup::VarData
{
 public:
 
  VarData() = default;
  explicit VarData(Ref<IData> d)
  : data(d)
  {}
 
 public:
 
  Ref<IData> data;
  Integer data_index = 0;
  DataCompressionBuffer m_data_buffer;
  Ref<IDataCompressor> m_compressor;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshMaterialBackup::
MeshMaterialBackup(IMeshMaterialMng* mm, bool use_unique_ids)
: TraceAccessor(mm->traceMng())
, m_material_mng(mm)
, m_use_unique_ids(use_unique_ids)
{
  m_compressor_service_name = mm->dataCompressorServiceName();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
MeshMaterialBackup::
~MeshMaterialBackup()
{
  for (const auto& iter : m_saved_data)
    delete iter.second;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
saveValues()
{
  _save();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
restoreValues()
{
  _restore();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
setCompressorServiceName(const String& name)
{
  m_compressor_service_name = name;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

bool MeshMaterialBackup::
_isValidComponent(IMeshMaterialVariable* var, IMeshComponent* component)
{
  MatVarSpace mvs = var->space();
  if (mvs == MatVarSpace::MaterialAndEnvironment)
    return true;
  if (mvs == MatVarSpace::Environment && component->isEnvironment())
    return true;
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_save()
{
  if (!m_compressor_service_name.null())
    m_use_v2 = true;
 
  ConstArrayView<MeshMaterialVariableIndexer*> indexers = m_material_mng->_internalApi()->variablesIndexer();
 
  Integer nb_index = indexers.size();
  Integer nb_value = 0;
  for (Integer i = 0; i < nb_index; ++i)
    nb_value += indexers[i]->cells().size();
 
  info(4) << "NB_EXPECTED_VALUE=" << nb_value;
 
  MeshMaterialMng* mm = dynamic_cast<MeshMaterialMng*>(m_material_mng);
  if (!mm)
    ARCANE_FATAL("Can not cast to MeshMaterialMng");
 
  // Store in \a vars the list of variables for easier access than with the map
  Integer max_nb_var = arcaneCheckArraySize(mm->m_full_name_variable_map.size());
  m_vars.reserve(max_nb_var);
  for (const auto& i : mm->m_full_name_variable_map) {
    IMeshMaterialVariable* mv = i.second;
    if (mv->keepOnChange() && mv->globalVariable()->isUsed())
      m_vars.add(mv);
  }
  for (IMeshMaterialVariable* mv : m_vars) {
    info(4) << "SAVE MVAR=" << mv->name() << " is_used?=" << mv->globalVariable()->isUsed();
    VarData* vd = new VarData(mv->_internalApi()->internalCreateSaveDataRef(nb_value));
    m_saved_data.insert(std::make_pair(mv, vd));
  }
 
  if (m_use_v2)
    _saveV2();
  else
    _saveV1();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_saveV1()
{
  ENUMERATE_COMPONENT (ic, m_material_mng->components()) {
    IMeshComponent* c = *ic;
    _saveIds(c);
    for (IMeshMaterialVariable* var : m_vars) {
      if (_isValidComponent(var, c))
        var->_internalApi()->saveData(c, m_saved_data[var]->data.get());
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_saveV2()
{
  IMesh* mesh = m_material_mng->mesh();
  ServiceBuilder<IDataCompressor> sb(mesh->handle().application());
  Ref<IDataCompressor> compressor_ref;
  if (!m_compressor_service_name.empty())
    compressor_ref = sb.createReference(m_compressor_service_name);
  IDataCompressor* compressor = compressor_ref.get();
  auto components = m_material_mng->components();
 
  ENUMERATE_COMPONENT (ic, components) {
    IMeshComponent* c = *ic;
    _saveIds(c);
  }
 
  for (IMeshMaterialVariable* var : m_vars) {
    VarData* var_data = m_saved_data[var];
    IData* saved_data = var_data->data.get();
    if (compressor) {
      var_data->m_compressor = compressor_ref;
      var_data->m_data_buffer.m_compressor = compressor;
    }
    ENUMERATE_COMPONENT (ic, components) {
      IMeshComponent* c = *ic;
      if (_isValidComponent(var, c)) {
        var->_internalApi()->saveData(c, saved_data);
      }
    }
    if (compressor) {
      IDataInternal* d = saved_data->_commonInternal();
      d->compressAndClear(var_data->m_data_buffer);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_saveIds(IMeshComponent* component)
{
  if (m_use_unique_ids) {
    auto& ids = m_unique_ids_array[component];
    ENUMERATE_COMPONENTCELL (icell, component) {
      ComponentCell ec = *icell;
      ids.add(ec.globalCell().uniqueId());
    }
    info(4) << "SAVE (uid) for component name=" << component->name()
            << " nb=" << ids.size();
  }
  else {
    Int32Array& ids = m_ids_array[component];
    ENUMERATE_COMPONENTCELL (icell, component) {
      ComponentCell ec = *icell;
      ids.add(ec.globalCell().localId());
    }
    info(4) << "SAVE (lid) for component name=" << component->name()
            << " nb=" << ids.size();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_restore()
{
  if (m_use_unique_ids) {
    info(4) << "RESTORE using uniqueIds()";
    IItemFamily* cell_family = m_material_mng->mesh()->cellFamily();
    // If uniqueIds() are used, the m_unique_ids_array
    // contains the uniqueId() values of the cells. It must
    // then be converted to localId().
    for (const auto& iter : m_unique_ids_array) {
      IMeshComponent* component = iter.first;
      auto& unique_ids = m_unique_ids_array[component];
      auto& local_ids = m_ids_array[component];
      local_ids.resize(unique_ids.size());
      cell_family->itemsUniqueIdToLocalId(local_ids, unique_ids, false);
    }
  }
 
  if (m_use_v2)
    _restoreV2();
  else
    _restoreV1();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_restoreV1()
{
  // If uniqueIds() are used, then localIds() may be null
  // if cells have been deleted.
  bool allow_null_id = m_use_unique_ids;
 
  ENUMERATE_COMPONENT (ic, m_material_mng->components()) {
    IMeshComponent* c = *ic;
    Int32ConstArrayView ids = m_ids_array[c];
    info(4) << "RESTORE for component name=" << c->name() << " nb=" << ids.size();
    for (IMeshMaterialVariable* var : m_vars) {
      VarData* vd = m_saved_data[var];
      if (_isValidComponent(var, c)) {
        var->_internalApi()->restoreData(c, vd->data.get(), vd->data_index, ids, allow_null_id);
        vd->data_index += ids.size();
      }
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void MeshMaterialBackup::
_restoreV2()
{
  // If uniqueIds() are used, then localIds() may be null
  // if cells have been deleted.
  bool allow_null_id = m_use_unique_ids;
 
  auto components = m_material_mng->components();
 
  for (IMeshMaterialVariable* var : m_vars) {
    VarData* vd = m_saved_data[var];
    // Decompress the data if necessary
    IDataCompressor* compressor = vd->m_data_buffer.m_compressor;
    if (compressor) {
      info(5) << "RESTORE decompress variable name=" << var->name();
      IDataInternal* d = vd->data->_commonInternal();
      d->decompressAndFill(vd->m_data_buffer);
    }
    info(4) << "RESTORE for variable name=" << var->name();
    ENUMERATE_COMPONENT (ic, components) {
      IMeshComponent* c = *ic;
      Int32ConstArrayView ids = m_ids_array[c];
      if (_isValidComponent(var, c)) {
        var->_internalApi()->restoreData(c, vd->data.get(), vd->data_index, ids, allow_null_id);
        vd->data_index += ids.size();
      }
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Materials
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/