SolutionInvalidity.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

// MOOSE Includes
#include "MooseTypes.h"
#include "MooseError.h"
#include "SolutionInvalidityRegistry.h"
#include "ConsoleStream.h"
#include "ConsoleStreamInterface.h"

// System Includes
#include <array>
#include <atomic>
#include <thread>
#include <future>
#include <mutex>

// libMesh Includes
#include "libmesh/parallel_object.h"

// Forward Declarations
template <class... Ts>
class VariadicTable;

class SolutionInvalidity : protected ConsoleStreamInterface, public libMesh::ParallelObject
{
public:
  using SolutionInvalidityRegistry = moose::internal::SolutionInvalidityRegistry;

  SolutionInvalidity(MooseApp & app);

  void flagInvalidSolutionInternal(const InvalidSolutionID _invalid_solution_id);

  bool hasInvalidSolutionWarning() const;

  bool hasInvalidSolutionError() const;

  bool hasInvalidSolution() const;

  void resetSolutionInvalidTimeStep();

  void resetSolutionInvalidCurrentIteration();

  void solutionInvalidAccumulation();

  void solutionInvalidAccumulationTimeStep(const unsigned int timestep_index);

  void computeTotalCounts();

  struct TimestepCounts
  {
    TimestepCounts() : timestep_index(std::numeric_limits<unsigned int>::max()) {}
    TimestepCounts(unsigned int timestep_index) : timestep_index(timestep_index) {}
    unsigned int timestep_index;
    unsigned int counts = 0;
  };

  struct InvalidCounts
  {
    unsigned int current_counts = 0;
    unsigned int current_timestep_counts = 0;
    unsigned int total_counts = 0;
    std::vector<TimestepCounts> timestep_counts;
  };

  const std::vector<InvalidCounts> & counts() const { return _counts; }

  void print(const ConsoleStream & console) const;

  void printHistory(const ConsoleStream & console, unsigned int & timestep_interval_size) const;

  void printDebug(InvalidSolutionID _invalid_solution_id) const;

  void syncIteration();

  friend void dataStore(std::ostream &, SolutionInvalidity &, void *);
  friend void dataLoad(std::istream &, SolutionInvalidity &, void *);

private:
  mutable std::mutex _invalid_mutex;

  typedef VariadicTable<std::string,
                        unsigned long int,
                        unsigned long int,
                        unsigned long int,
                        std::string>
      FullTable;

  FullTable summaryTable() const;

  typedef VariadicTable<std::string, std::string, unsigned long int, unsigned long int> TimeTable;

  TimeTable transientTable(unsigned int & time_interval) const;

  SolutionInvalidityRegistry & _solution_invalidity_registry;

  std::vector<InvalidCounts> _counts;

  bool _has_synced;
  bool _has_solution_warning;
  bool _has_solution_error;
};

// datastore and dataload for recover
void dataStore(std::ostream & stream,
               SolutionInvalidity::TimestepCounts & timestep_counts,
               void * context);
void dataLoad(std::istream & stream,
              SolutionInvalidity::TimestepCounts & timestep_counts,
              void * context);
void dataStore(std::ostream & stream, SolutionInvalidity & solution_invalidity, void * context);
void dataLoad(std::istream & stream, SolutionInvalidity & solution_invalidity, void * context);