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;
 
  bool hasEverHadSolutionIssue() const;
 
  void resetTimeStepOccurences();
 
  void resetIterationOccurences();
 
  void accumulateIterationIntoTimeStepOccurences();
 
  void accumulateTimeStepIntoTotalOccurences(const unsigned int timestep_index);
 
  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();
 
  bool hasSynced() const { return _has_synced; }
 
  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;
  bool _has_recorded_issue;
};
 
// 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);