OutputChecker.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* OutputChecker.cc                                            (C) 2000-2016 */
/*                                                                           */
/* Outputs based on time (physical or CPU) or number of iterations.          */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcanePrecomp.h"
 
#include "arcane/utils/CheckedConvert.h"
#include "arcane/utils/ITraceMng.h"
 
#include "arcane/core/ISubDomain.h"
#include "arcane/core/ICaseFunction.h"
#include "arcane/core/CommonVariables.h"
 
#include "arcane/core/OutputChecker.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
OutputChecker::
OutputChecker(ISubDomain* sd, const String& name)
: m_sub_domain(sd)
, m_name(name)
, m_out_type(OutTypeNone)
, m_next_iteration(0)
, m_next_global_time(0)
, m_next_cpu_time(0)
, m_step_iteration(0)
, m_step_global_time(0)
, m_step_cpu_time(0)
{}
 
void OutputChecker::
assignGlobalTime(VariableScalarReal* variable, const CaseOptionReal* option)
{
  m_next_global_time = variable;
  m_step_global_time = option;
}
 
void OutputChecker::
assignCPUTime(VariableScalarInteger* variable, const CaseOptionInteger* option)
{
  m_next_cpu_time = variable;
  m_step_cpu_time = option;
}
 
void OutputChecker::
assignIteration(VariableScalarInteger* variable, const CaseOptionInteger* option)
{
  m_next_iteration = variable;
  m_step_iteration = option;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*!
 * \brief Checks whether an output should be performed.
 *
 * \arg \a old_time and \a current_time are used for physical time outputs.
 * \arg \a current_iteration is used for iteration count outputs.
 * \arg \a cpu_time_used is used for CPU time outputs.
 
 When an output type is not available, the associated value(s)
 are not used and may be arbitrary.
 
 * \param old_time physical time of the previous iteration.
 * \param current_time current physical time.
 * \param current_iteration current iteration.
 * \param cpu_time_used CPU time used
 */
bool OutputChecker::
check(Real old_time, Real current_time,
      Integer current_iteration, Integer cpu_time_used,
      const String& from_function)
{
  String function_id = "OutputChecker::check >>> ";
 
  if (m_out_type == OutTypeNone)
    return false;
 
  ITraceMng* trace = m_sub_domain->traceMng();
 
  // \a true if we are going to perform an output
  bool do_output = false;
  switch (m_out_type) {
  case OutTypeGlobalTime: {
    Real next_time = (*m_next_global_time)();
    trace->debug() << from_function << function_id << "Next out: " << next_time << " Saved Time: " << old_time
                   << " Current time: " << current_time << " step=" << m_step_global_time;
    //if (math::isEqual(m_next_time(),old_time))
    if (math::isEqual(next_time, current_time))
      do_output = true;
    // To perform an output, we must have exceeded
    // the previous time and the current time must be #strictly# greater
    // than the output time.
    else if (next_time > old_time && next_time < current_time) {
      do_output = true;
    }
    // TODO: divide by the number of output steps
    if (do_output || next_time < old_time) {
      //Real to_add = m_step_time(); //old_time);
      // If the time is given by a step table, its value must be taken
      // at the current instant.
      // We must take the value
      Real to_add = m_step_global_time->valueAtParameter(current_time); //old_time);
      if (!math::isZero(to_add)) {
        //m_next_time += to_add;
        Real diff = (current_time - next_time) / to_add;
        if (diff < 0.)
          *m_next_global_time = next_time + to_add;
        else {
          double i_diff = math::floor(diff);
          *m_next_global_time = next_time + (to_add * (i_diff + 1));
        }
        trace->debug() << from_function << function_id
                       << "Next output at time " << next_time
                       << " (" << to_add << ' ' << old_time
                       << ' ' << current_iteration << ")";
      }
    }
  } break;
  case OutTypeIteration: {
    Integer next_iteration = (*m_next_iteration)();
    Integer to_add = m_step_iteration->valueAtParameter(current_time);
 
    if (next_iteration > current_iteration + to_add) {
      // TH: In case of resumption with decrease in output period in days
      // TH: we resume outputs immediately
      next_iteration = current_iteration;
    }
 
    if (next_iteration == current_iteration)
      do_output = true;
 
    // Calculate the next save iteration if necessary
    if (next_iteration <= current_iteration) {
      if (to_add != 0) {
        Integer diff = (current_iteration - next_iteration) / to_add;
        (*m_next_iteration) = next_iteration + ((diff + 1) * to_add);
        trace->debug() << from_function << function_id
                       << "Next output at iteration " << (*m_next_iteration)()
                       << " (" << to_add << ' ' << old_time
                       << ' ' << current_iteration << " diff=" << diff << ")";
      }
    }
  } break;
  case OutTypeCPUTime: {
    Integer next_cpu_time = (*m_next_cpu_time)();
    Integer cpu_time = cpu_time_used;
    // Convert CPU time to minutes (to remain consistent with the conversion
    // in _recomputeTypeCPUTime())
 
    Integer current_cpu_time = cpu_time / 60;
 
    if (next_cpu_time <= current_cpu_time)
      do_output = true;
 
    // Calculate the next save CPU time if necessary
    if (next_cpu_time <= current_cpu_time) {
      Integer to_add = m_step_cpu_time->valueAtParameter(current_time);
      if (to_add != 0) {
        Integer diff = (current_cpu_time - next_cpu_time) / to_add;
        (*m_next_cpu_time) = next_cpu_time + ((diff + 1) * to_add);
        trace->debug() << from_function << function_id
                       << "Next output at cpu time " << (*m_next_cpu_time)()
                       << " (" << to_add << ' ' << current_cpu_time << " diff=" << diff << ")";
      }
    }
 
    // Does nothing for the first minute.
    if (current_cpu_time == 0)
      do_output = false;
 
    //if (do_output)
    //cerr << "** ** OUTPUT AT CPU TIME " << cpu_time
    //<< ' ' << current_cpu_time << ' ' << (*m_next_cpu_time)()
    //   << ' ' << (*m_step_cpu_time)() << '\n';
 
  }
  //msg->warning() << "Not implemented";
  break;
  case OutTypeNone:
    break;
  }
 
  return do_output;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void OutputChecker::
_recomputeTypeGlobalTime()
{
  Real current_time = m_sub_domain->commonVariables().globalTime();
  Real step = m_step_global_time->valueAtParameter(current_time);
 
  Real old_next = (*m_next_global_time)();
  Real next = old_next;
  Real current_value = current_time;
  if (!math::isZero(step)) {
    Real index = ::floor(current_value / step);
    next = step * (index + 1.0);
    *m_next_global_time = next;
  }
 
  ITraceMng* tm = m_sub_domain->traceMng();
  tm->info(4) << "Recompute OutputChecker for Global Time: old=" << old_next
              << " new=" << next;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void OutputChecker::
_recomputeTypeCPUTime()
{
  Real current_time = m_sub_domain->commonVariables().globalTime();
  Integer step = m_step_cpu_time->valueAtParameter(current_time);
 
  Integer old_next = (*m_next_cpu_time)();
  Integer next = old_next;
  double current_value = math::floor(m_sub_domain->commonVariables().globalCPUTime());
 
  // Convert to minutes (to remain consistent with the conversion in check())
  current_value /= 60.0;
 
  if (step != 0) {
    Integer index = CheckedConvert::toInteger(current_value / step);
    next = step * (index + 1);
    *m_next_cpu_time = next;
  }
 
  ITraceMng* tm = m_sub_domain->traceMng();
  tm->info(4) << "Recompute OutputChecker for CPU Time: old=" << old_next << " new=" << next;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void OutputChecker::
_recomputeTypeIteration()
{
  Real current_time = m_sub_domain->commonVariables().globalTime();
  Integer step = m_step_iteration->valueAtParameter(current_time);
 
  Integer old_next = (*m_next_iteration)();
  Integer next = old_next;
  Integer current_value = m_sub_domain->commonVariables().globalIteration();
  if (step != 0) {
    if (old_next <= current_value) {
      *m_next_iteration = current_value;
    }
    else {
      Integer index = current_value / step;
      next = step * (index + 1);
      *m_next_iteration = next;
    }
  }
 
  ITraceMng* tm = m_sub_domain->traceMng();
  tm->info(4) << "Recompute OutputChecker for CPU Time: old=" << old_next << " new=" << next;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void OutputChecker::
initialize()
{
  initialize(false);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void OutputChecker::
initialize(bool recompute_next_value)
{
  ITraceMng* trace = m_sub_domain->traceMng();
  m_out_type = OutTypeNone;
 
  ICaseFunction* func = 0;
  // Prioritizes physical time outputs, then
  // iteration count, then CPU time.
  if (m_step_global_time && m_next_global_time && m_step_global_time->isPresent()) {
    m_out_type = OutTypeGlobalTime;
    func = m_step_global_time->function();
    if (func)
      trace->info() << "Output in real time controlled by function '" << func->name() << "'.";
    else
      trace->info() << "Output in real time every " << (*m_step_global_time)() << " seconds.";
    if (recompute_next_value)
      _recomputeTypeGlobalTime();
  }
  else if (m_step_iteration && m_next_iteration && m_step_iteration->value() != 0) {
    m_out_type = OutTypeIteration;
    func = m_step_iteration->function();
    if (func)
      trace->info() << "Output in iterations controlled by function '" << func->name() << "'.";
    else
      trace->info() << "Output every " << (*m_step_iteration)() << " iterations.";
    if (recompute_next_value)
      _recomputeTypeIteration();
  }
  else if (m_step_cpu_time && m_next_cpu_time && m_step_cpu_time->isPresent()) {
    m_out_type = OutTypeCPUTime;
    func = m_step_cpu_time->function();
    if (func)
      trace->info() << "Output in CPU time controlled by function '" << func->name() << "'.";
    else
      trace->info() << "Output in CPU time every " << (*m_step_cpu_time)() << " minutes.";
    if (recompute_next_value)
      _recomputeTypeCPUTime();
  }
  else
    trace->info() << "No output required.";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Real OutputChecker::
nextGlobalTime() const
{
  Real v = 0.0;
  if (m_next_global_time)
    v = (*m_next_global_time)();
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer OutputChecker::
nextIteration() const
{
  Integer v = 0;
  if (m_next_iteration)
    v = (*m_next_iteration)();
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Integer OutputChecker::
nextCPUTime() const
{
  Integer v = 0;
  if (m_next_cpu_time)
    v = (*m_next_cpu_time)();
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/