VariableScalar.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VariableScalar.cc                                           (C) 2000-2025 */
/*                                                                           */
/* Scalar variable.                                                          */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/VariableScalar.h"
 
#include "arcane/utils/NotSupportedException.h"
#include "arcane/utils/ArgumentException.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/Ref.h"
#include "arcane/utils/ITraceMng.h"
 
#include "arcane/core/VariableDiff.h"
#include "arcane/core/VariableBuildInfo.h"
#include "arcane/core/VariableInfo.h"
#include "arcane/core/IApplication.h"
#include "arcane/core/IVariableMng.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/IVariableSynchronizer.h"
#include "arcane/core/IDataReader.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/IDataFactoryMng.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/VariableComparer.h"
#include "arcane/core/internal/IVariableInternal.h"
#include "arcane/core/internal/IVariableMngInternal.h"
 
#include "arcane/core/datatype/DataStorageBuildInfo.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class DataType>
class ScalarVariableDiff
: public VariableDiff<DataType>
{
  typedef VariableDataTypeTraitsT<DataType> VarDataTypeTraits;
  typedef typename VariableDiff<DataType>::DiffInfo DiffInfo;
 
 public:
 
  //TODO: a simplifier car recopie de ArrayVariableDiff
  // but for scalar variables there is only one value and no associated group.
  VariableComparerResults
  check(IVariable* var, ConstArrayView<DataType> ref, ConstArrayView<DataType> current,
        const VariableComparerArgs& compare_args)
  {
    const bool compare_ghost = compare_args.isCompareGhost();
    ItemGroup group = var->itemGroup();
    if (group.null())
      return {};
    IMesh* mesh = group.mesh();
    if (!mesh)
      return {};
    ITraceMng* msg = mesh->traceMng();
    IParallelMng* pm = mesh->parallelMng();
 
    GroupIndexTable* group_index_table = (var->isPartial()) ? group.localIdToIndex().get() : nullptr;
 
    int nb_diff = 0;
    bool compare_failed = false;
    Integer ref_size = ref.size();
    ENUMERATE_ITEM (i, group) {
      const Item& item = *i;
      if (!item.isOwn() && !compare_ghost)
        continue;
      Integer index = item.localId();
      if (group_index_table) {
        index = (*group_index_table)[index];
        if (index < 0)
          continue;
      }
 
      DataType diff = DataType();
      if (index >= ref_size) {
        ++nb_diff;
        compare_failed = true;
      }
      else {
        DataType dref = ref[index];
        DataType dcurrent = current[index];
        if (VarDataTypeTraits::verifDifferent(dref, dcurrent, diff, true)) {
          this->m_diffs_info.add(DiffInfo(dcurrent, dref, diff, item, NULL_ITEM_ID));
          ++nb_diff;
        }
      }
    }
    if (compare_failed) {
      Int32 sid = pm->commRank();
      const String& var_name = var->name();
      msg->pinfo() << "Processor " << sid << " : "
                   << " Unable to compare : elements numbers are different !"
                   << " for the variable " << var_name << " ref_size=" << ref_size;
    }
    if (nb_diff != 0)
      this->_sortAndDump(var, pm, compare_args);
 
    return VariableComparerResults(nb_diff);
  }
 
  VariableComparerResults
  checkReplica(IVariable* var, const DataType& var_value,
               const VariableComparerArgs& compare_args)
  {
    IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
    if (!replica_pm)
      return {};
    const int max_print = compare_args.maxPrint();
    // Calls the correct specialization to ensure the template type has
    // the reduction.
    using ReduceType = typename VariableDataTypeTraitsT<DataType>::HasReduceMinMax;
    if constexpr (std::is_same<TrueType, ReduceType>::value)
      return _checkReplica2(replica_pm, var_value);
    ARCANE_UNUSED(replica_pm);
    ARCANE_UNUSED(var);
    ARCANE_UNUSED(var_value);
    ARCANE_UNUSED(max_print);
    throw NotSupportedException(A_FUNCINFO);
  }
 
 private:
 
  VariableComparerResults
  _checkReplica2(IParallelMng* pm, const DataType& var_value)
  {
    Int32 nb_rank = pm->commSize();
    if (nb_rank == 1)
      return {};
 
    DataType max_value = pm->reduce(Parallel::ReduceMax, var_value);
    DataType min_value = pm->reduce(Parallel::ReduceMin, var_value);
 
    Integer nb_diff = 0;
    DataType diff = DataType();
    if (VarDataTypeTraits::verifDifferent(min_value, max_value, diff, true)) {
      this->m_diffs_info.add(DiffInfo(min_value, max_value, diff, 0, NULL_ITEM_ID));
      ++nb_diff;
    }
    return VariableComparerResults(nb_diff);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> VariableScalarT<T>::
VariableScalarT(const VariableBuildInfo& v, const VariableInfo& info)
: Variable(v, info)
, m_value(nullptr)
{
  IDataFactoryMng* df = v.dataFactoryMng();
  DataStorageBuildInfo storage_build_info(v.traceMng());
  String storage_full_type = info.storageTypeInfo().fullName();
  Ref<IData> data = df->createSimpleDataRef(storage_full_type, storage_build_info);
  m_value = dynamic_cast<ValueDataType*>(data.get());
  _setData(makeRef(m_value));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> auto VariableScalarT<T>::
getReference(const VariableBuildInfo& vb, const VariableInfo& vi) -> ThatClass*
{
  ThatClass* true_ptr = 0;
  IVariableMng* vm = vb.variableMng();
  IVariable* var = vm->checkVariable(vi);
  if (var)
    true_ptr = dynamic_cast<ThatClass*>(var);
  else {
    true_ptr = new ThatClass(vb, vi);
    vm->_internalApi()->addVariable(true_ptr);
  }
  ARCANE_CHECK_PTR(true_ptr);
  return true_ptr;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> VariableScalarT<T>* VariableScalarT<T>::
getReference(IVariable* var)
{
  if (!var)
    throw ArgumentException(A_FUNCINFO, "null variable");
  ThatClass* true_ptr = dynamic_cast<ThatClass*>(var);
  if (!true_ptr)
    ARCANE_FATAL("Can not build a reference from variable {0}", var->name());
  return true_ptr;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// Use a Helper function to specialize the call in the
// case of the 'Byte' type because ArrayVariableDiff::checkReplica() uses
// a Min/Max reduction and this does not exist in MPI for the Byte type.
namespace
{
  template <typename T> VariableComparerResults
  _checkIfSameOnAllReplicaHelper(IVariable* var, const T& value,
                                 const VariableComparerArgs& compare_args)
  {
    ScalarVariableDiff<T> csa;
    return csa.checkReplica(var, value, compare_args);
  }
 
  // Specialization for the 'Byte' type which does not support reductions.
  VariableComparerResults
  _checkIfSameOnAllReplicaHelper(IVariable* var, const Byte& value,
                                 const VariableComparerArgs& compare_args)
  {
    Integer int_value = value;
    ScalarVariableDiff<Integer> csa;
    return csa.checkReplica(var, int_value, compare_args);
  }
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> VariableComparerResults VariableScalarT<T>::
_compareVariable(const VariableComparerArgs& compare_args)
{
  switch (compare_args.compareMode()) {
  case eVariableComparerCompareMode::Same: {
 
    if (itemKind() == IK_Particle)
      return {};
    IDataReader* reader = compare_args.dataReader();
    ARCANE_CHECK_POINTER(reader);
    T from(value());
    T ref = T();
    Ref<IScalarDataT<T>> ref_data(m_value->cloneTrueEmptyRef());
    reader->read(this, ref_data.get());
    ref = ref_data->value();
    ConstArrayView<T> from_array(1, &from);
    ConstArrayView<T> ref_array(1, &ref);
    ScalarVariableDiff<T> csa;
    VariableComparerResults r = csa.check(this, ref_array, from_array, compare_args);
    return r;
  }
  case eVariableComparerCompareMode::Sync:
    return {};
  case eVariableComparerCompareMode::SameOnAllReplica: {
    VariableComparerResults r = _checkIfSameOnAllReplicaHelper(this, value(), compare_args);
    return r;
  }
  }
  ARCANE_FATAL("Invalid value for compare mode '{0}'", (int)compare_args.compareMode());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
print(std::ostream& o) const
{
  o << m_value->value();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
synchronize()
{
  // Nothing to do for scalar variables
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
synchronize(Int32ConstArrayView local_ids)
{
  // Nothing to do for scalar variables
  ARCANE_UNUSED(local_ids);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> Real VariableScalarT<T>::
allocatedMemory() const
{
  return static_cast<Real>(sizeof(T));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination)
{
  ARCANE_UNUSED(source);
  ARCANE_UNUSED(destination);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
copyItemsMeanValues(Int32ConstArrayView first_source,
                    Int32ConstArrayView second_source,
                    Int32ConstArrayView destination)
{
  ARCANE_UNUSED(first_source);
  ARCANE_UNUSED(second_source);
  ARCANE_UNUSED(destination);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
compact(Int32ConstArrayView new_to_old_ids)
{
  ARCANE_UNUSED(new_to_old_ids);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
setIsSynchronized()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void VariableScalarT<T>::
setIsSynchronized(const ItemGroup& group)
{
  ARCANE_UNUSED(group);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename DataType> void
VariableScalarT<DataType>::
swapValues(ThatClass& rhs)
{
  _checkSwapIsValid(&rhs);
  m_value->swapValues(rhs.m_value);
  // References must be updated for this variable and \a rhs.
  syncReferences();
  rhs.syncReferences();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(VariableScalarT);
template class VariableScalarT<String>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/