SolverStatistics.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
/*
 * @file SolverStatistics.hpp
 */
 
 
#ifndef GEOS_PHYSICSSOLVERS_SOLVERSTATISTICS_HPP
#define GEOS_PHYSICSSOLVERS_SOLVERSTATISTICS_HPP
 
#include "dataRepository/Group.hpp"
#include "common/format/table/TableData.hpp"
#include "common/format/table/TableFormatter.hpp"
#include "common/format/table/TableLayout.hpp"
#include "common/format/table/TableTypes.hpp"
 
namespace geos
{
 
class IterationsStatistics : public dataRepository::Group
{
public:
 
  IterationsStatistics( string const & name,
                        dataRepository::Group * const parent );
 
  struct viewKeyStruct
  {
    static constexpr char const * numTimeStepsString() { return "numTimeSteps"; }
    static constexpr char const * numTimeStepCutsString() { return "numTimeStepCuts"; }
 
    static constexpr char const * numSuccessfulConfigIterationsString() { return "numSuccessfulConfigIterations"; }
    static constexpr char const * numSuccessfulNonlinearIterationsString() { return "numSuccessfulNonlinearIterations"; }
    static constexpr char const * numSuccessfulLinearIterationsString() { return "numSuccessfulLinearIterations"; }
 
    static constexpr char const * numDiscardedConfigIterationsString() { return "numDiscardedConfigIterations"; }
    static constexpr char const * numDiscardedNonlinearIterationsString() { return "numDiscardedNonlinearIterations"; }
    static constexpr char const * numDiscardedLinearIterationsString() { return "numDiscardedLinearIterations"; }
  };
 
  void setCSVOutputState( bool state )
  { m_csvOutputEnabled = state; }
 
  void setLogOutputState( bool state )
  { m_logOutput = state; }
 
 
  void resetCurrentTimeStepStatistics();
 
  void incrementConfigIteration();
 
  void updateNonlinearIteration( integer const numLinearIterations );
 
  void accumulateSolverLinearTime( real64 setupTime, real64 solveTime );
 
  void resetSolverLinearTime();
 
  void updateTimeStepCut();
 
  void iterateTimeStepStatistics();
 
  void writeIterationStatsToTable();
 
  void setFilename( string_view filename )
  { m_iterationsFilename = filename; }
 
 
  string const & getFilename() const
  { return m_iterationsFilename;  }
 
  string & getFilename()
  { return m_iterationsFilename;  }
 
 
  void setTableName( string_view name )
  { m_tableIterationName = name; }
 
  void outputStatistics() const;
 
  void closeFile()
  { if( m_csvOutputOpened ) { m_logStream.close(); m_csvOutputOpened = false; } }
 
protected:
 
  integer m_numTimeSteps = 0;
 
  integer m_numTimeStepCuts = 0;
 
  integer m_currentNumConfigIterations = 0;
 
  integer m_currentNumNonlinearIterations = 0;
 
  integer m_currentNumLinearIterations = 0;
 
  integer m_numSuccessfulConfigIterations = 0;
 
  integer m_numSuccessfulNonlinearIterations = 0;
 
  integer m_numSuccessfulLinearIterations = 0;
 
  integer m_numDiscardedConfigIterations  = 0;
 
  integer m_numDiscardedNonlinearIterations = 0;
 
  integer m_numDiscardedLinearIterations = 0;
 
  real64 m_setupTime = 0.0;
 
  real64 m_solveTime = 0.0;
 
private:
  bool m_logOutput = false;
  bool m_csvOutputEnabled = false;
  bool m_csvOutputOpened  = false;
  std::ofstream m_logStream;
  TableLayout m_iterationCSVLayout;
  TableData m_iterationData;
  std::unique_ptr< TableCSVFormatter > m_iterationCSVFormatter;
  string m_tableIterationName;
  string m_iterationsFilename;
};
 
class ConvergenceStatistics
{
public:
 
  ConvergenceStatistics();
 
  bool m_csvOutputEnabled = false;
 
  void setCSVOutputState( bool state )
  { m_csvOutputEnabled = state; }
 
  void writeConvergenceStatsToTable();
 
  void updateSolverStep( real64 const & time_n,
                         real64 const & dt,
                         integer const cycleNumber,
                         integer const newtonIter );
 
  void setResidualValue( string const & key, real64 const value )
  { if( m_csvOutputEnabled ) m_residuals[key] = value; }
 
  void setFilename( string_view filename )
  { m_convergenceFilename = filename; }
 
  void setTableName( string_view name )
  { m_tableConvergenceName = name; }
 
  string const & getFilename() const
  { return m_convergenceFilename;  }
 
  string & getFilename()
  { return m_convergenceFilename;  }
 
  void closeFile()
  {  if( m_csvOutputOpened ) { m_logStream.close(); m_csvOutputOpened = false; } }
 
private:
  real64 m_time_n = 0.0;
 
  real64 m_dt = 0.0;
 
  integer m_cycleNumber = 0;
 
  integer m_iteration = 0;
 
  std::map< string, real64 > m_residuals;
 
  bool m_csvOutputOpened  = false;
  std::ofstream m_logStream;
  TableLayout m_convergenceLayout;
  TableData m_convergenceData;
  std::unique_ptr< TableCSVFormatter > m_convergenceFormatter;
  string m_tableConvergenceName;
  string m_convergenceFilename;
};
 
class SolverStatistics : public dataRepository::Group
{
public:
  SolverStatistics( string const & name,
                    dataRepository::Group * const parent );
 
  struct groupKeyStruct
  {
    static constexpr char const * IterationsStatisticsString() { return "IterationsStatistics"; }
  };
 
  void makeDir( bool writeSolverIteration )
  { if( writeSolverIteration ) makeDirsForPath( m_outputDir ); }
 
  void setOutputFilesName( string_view solverName );
 
  IterationsStatistics m_iterationsStats;
  ConvergenceStatistics m_convergenceStats;
 
protected:
  string m_outputDir;
 
private:
  string m_directoryName = "convergence";
};
 
} //namespace geos
 
#endif // GEOS_PHYSICSSOLVERS_SOLVERSTATISTICS_HPP