OutputChecker.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 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 */
/*                                                                           */
/* Sorties basées sur un temps (physique ou CPU) ou un nombre d'itération.   */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcanePrecomp.h"
 
#include "arcane/utils/CheckedConvert.h"
#include "arcane/utils/ITraceMng.h"
 
#include "arcane/ISubDomain.h"
#include "arcane/ICaseFunction.h"
#include "arcane/CommonVariables.h"
 
#include "arcane/OutputChecker.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
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;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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 si on va effectuer une sortie
  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;
      // Pour faire une sortie, il faut qu'on ait dépassé
      // le temps précédent et que le temps courant soit #strictement# supérieur
      // au temps de la sortie.
      else if (next_time>old_time && next_time<current_time){
        do_output = true;
      }
      // TODO: diviser par le nombre de pas de sorties
      if (do_output || next_time<old_time){
        //Real to_add = m_step_time(); //old_time);
        // S'il le temps est donné par une table de marche, il faut prendre
        // sa valeur à l'instant courant.
        //Il faut prendre la valeur 
        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: En cas de reprise avec diminution de la période de sortie dans jdd
        // TH: on reprend les sorties tout de suite
        next_iteration = current_iteration;
      }
 
      if (next_iteration==current_iteration) do_output = true;
       
      // Calcule la prochaine itération de sauvegarde si nécessaire
      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;
      // Converti le temps CPU en minutes (à garder cohérent avec la conversion dans _recomputeTypeCPUTime())
 
      Integer current_cpu_time  = cpu_time / 60;       
 
      if (next_cpu_time<=current_cpu_time)
        do_output = true;
       
      // Calcule le prochain temps CPU de sauvegarde si nécessaire
      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 << ")";
        }
      }
 
      // Ne fait rien la première 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());
 
  // Converti en minute (à garder cohérent avec la conversion dans 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;
  // Prioritairement prend les sorties en temps physique, puis en
  // nombre d'itérations, puis en temps CPU.
  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;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/