VariableComparer.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VariableComparer.h                                          (C) 2000-2025 */
/*                                                                           */
/* Classe pour effectuer des comparaisons entre les variables.               */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_VARIABLECOMPARER_H
#define ARCANE_CORE_VARIABLECOMPARER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/TraceAccessor.h"
 
#include "arcane/core/ArcaneTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class eVariableComparerCompareMode
{
  Same = 0,
  Sync = 1,
  SameReplica = 2
};

enum class eVariableComparerComputeDifferenceMethod
{
  Relative,
  LocalNormMax,
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT VariableComparerArgs
{
 public:

  void setMaxPrint(Int32 v) { m_max_print = v; }
  Int32 maxPrint() const { return m_max_print; }

  void setCompareGhost(bool v) { m_is_compare_ghost = v; }
  bool isCompareGhost() const { return m_is_compare_ghost; }
 
  void setDataReader(IDataReader* v) { m_data_reader = v; }
  IDataReader* dataReader() const { return m_data_reader; }
 
  void setCompareMode(eVariableComparerCompareMode v) { m_compare_mode = v; }
  eVariableComparerCompareMode compareMode() const { return m_compare_mode; }
 
  void setComputeDifferenceMethod(eVariableComparerComputeDifferenceMethod v) { m_compute_difference_method = v; }
  eVariableComparerComputeDifferenceMethod computeDifferenceMethod() const { return m_compute_difference_method; }
 
  void setReplicaParallelMng(IParallelMng* pm) { m_replica_parallel_mng = pm; }
  IParallelMng* replicaParallelMng() const { return m_replica_parallel_mng; }
 
 private:
 
  Int32 m_max_print = 0;
  bool m_is_compare_ghost = false;
  IDataReader* m_data_reader = nullptr;
  eVariableComparerCompareMode m_compare_mode = eVariableComparerCompareMode::Same;
  eVariableComparerComputeDifferenceMethod m_compute_difference_method = eVariableComparerComputeDifferenceMethod::Relative;
  IParallelMng* m_replica_parallel_mng = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT VariableComparerResults
{
 public:
 
  VariableComparerResults() = default;
  explicit VariableComparerResults(Int32 nb_diff)
  : m_nb_diff(nb_diff)
  {}
 
 public:
 
  void setNbDifference(Int32 v) { m_nb_diff = v; }
  Int32 nbDifference() const { return m_nb_diff; }
 
 public:
 
  Int32 m_nb_diff = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT VariableComparer
: public TraceAccessor
{
 public:
 
  explicit VariableComparer(ITraceMng* tm);
 
 public:

  Int32 checkIfSync(IVariable* var, Int32 max_print);

  Int32 checkIfSame(IVariable* var, IDataReader* reader, Int32 max_print, bool compare_ghost);

  Int32 checkIfSameOnAllReplica(IVariable* var, Integer max_print);
 
 public:

  VariableComparerArgs buildForCheckIfSame(IDataReader* data_reader);

  VariableComparerResults apply(IVariable* var, const VariableComparerArgs& compare_args);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif