ReporterState.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
 
#include <iostream>
 
#include "libmesh/parallel.h"
#include "libmesh/parallel_object.h"
#include "libmesh/simple_range.h"
 
#include "ReporterName.h"
#include "RestartableData.h"
#include "ReporterMode.h"
 
// Forward declarations
class MooseObject;
class ReporterContextBase;
 
class ReporterStateBase
{
public:
  ReporterStateBase(const ReporterName & name);
  virtual ~ReporterStateBase() = default;
 
  const ReporterName & getReporterName() const { return _reporter_name; }
 
  void addConsumer(ReporterMode mode, const MooseObject & moose_object);
 
  const std::set<std::pair<ReporterMode, const MooseObject *>> & getConsumers() const
  {
    return _consumers;
  }
 
  virtual std::string valueType() const = 0;
 
  void setIsPostprocessor() { _reporter_name.setIsPostprocessor(); }
  void setIsVectorPostprocessor() { _reporter_name.setIsVectorPostprocessor(); }
 
private:
  ReporterName _reporter_name;
 
  std::set<std::pair<ReporterMode, const MooseObject *>> _consumers;
};
 
bool operator<(const std::pair<ReporterMode, const MooseObject *> & a,
               const std::pair<ReporterMode, const MooseObject *> & b);
 
template <typename T>
class ReporterState : public ReporterStateBase, public RestartableData<std::list<T>>
{
public:
  ReporterState(const ReporterName & name);
 
 
  T & value(const std::size_t time_index = 0);
  const T & value(const std::size_t time_index = 0) const;
 
  void copyValuesBack();
 
  bool restoreState();
 
  std::string valueType() const override final { return MooseUtils::prettyCppType<T>(); }
 
  void storeInternal(std::ostream & stream) override final;
  void loadInternal(std::istream & stream) override final;
};
 
template <typename T>
ReporterState<T>::ReporterState(const ReporterName & name)
  : ReporterStateBase(name), RestartableData<std::list<T>>(name.getRestartableName(), nullptr)
{
}
 
template <typename T>
T &
ReporterState<T>::value(const std::size_t time_index)
{
  // Initialize the data; the first entry is the "current" data
  if (this->get().empty())
    this->set().resize(1);
 
  // If we are a postprocessor, we want to always store an old value so that we can restore the data
  // if needed. See restoreState.
  // Note: This can easily be extended to other states like vector-postprocessors or any other
  // reporter value. However, these states have indeterminate sizes and could create significant,
  // unecessary memory overhead. In the future, we can extend this to other reporter types if
  // the need justifies the overhead.
  if (this->getReporterName().isPostprocessor() && time_index == 0 && this->get().size() <= 1)
    this->set().push_back(this->get().back());
 
  // Initialize old, older, ... data
  if (this->get().size() <= time_index)
    this->set().resize(time_index + 1, this->get().back());
 
  return *(std::next(this->set().begin(), time_index));
}
 
template <typename T>
const T &
ReporterState<T>::value(const std::size_t time_index) const
{
  if (this->get().size() <= time_index)
    mooseError("The desired time index ",
               time_index,
               " does not exists for the '",
               getReporterName(),
               "' Reporter value, which contains ",
               this->get().size(),
               " old value(s). The getReporterValue method must be called with the desired time "
               "index to be able to access data.");
  return *(std::next(this->get().begin(), time_index));
}
 
template <typename T>
void
ReporterState<T>::copyValuesBack()
{
  std::list<T> & values = this->set();
  for (typename std::list<T>::reverse_iterator iter = values.rbegin();
       std::next(iter) != values.rend();
       ++iter)
    (*iter) = (*std::next(iter));
}
 
template <typename T>
bool
ReporterState<T>::restoreState()
{
  if (this->get().size() <= 1)
    return false;
 
  this->set().front() = *std::next(this->get().begin());
  return true;
}
 
template <typename T>
void
ReporterState<T>::storeInternal(std::ostream & stream)
{
  // Store the container size
  std::size_t size = this->get().size();
  dataStore(stream, size, nullptr);
 
  // Store each entry of the list directly into the storage
  for (auto & val : this->set())
    storeHelper(stream, val, nullptr);
}
 
template <typename T>
void
ReporterState<T>::loadInternal(std::istream & stream)
{
  // Read the container size
  std::size_t size = 0;
  dataLoad(stream, size, nullptr);
 
  auto & values = this->set();
 
  // If the current container is undersized, expand it to fit the loaded data
  if (values.size() < size)
    values.resize(size);
 
  // Load each entry of the list directly into the storage
  // Because we don't shrink the container if the stored size is smaller than
  // our declared size, we have the odd iterator combo you see below
  for (auto & val : as_range(values.begin(), std::next(values.begin(), size)))
    loadHelper(stream, val, nullptr);
}