libMesh::MemorySolutionHistory Class Reference

Stores past solutions in memory. More...

#include <memory_solution_history.h>

Inheritance diagram for libMesh::MemorySolutionHistory:

Public Types
typedef std::map< std::string, std::unique_ptr< NumericVector< Number > > >	map_type
typedef std::list< std::pair< Real, map_type > >	list_type
typedef list_type::iterator	stored_solutions_iterator

Public Member Functions
	MemorySolutionHistory (System &system_)
	~MemorySolutionHistory ()
virtual void	store () override
virtual void	retrieve () override
virtual std::unique_ptr< SolutionHistory >	clone () const override
void	set_overwrite_previously_stored (bool val)

Protected Attributes
bool	overwrite_previously_stored

Private Member Functions
void	find_stored_entry ()

Private Attributes
list_type	stored_solutions
stored_solutions_iterator	stored_sols
System &	_system

Detailed Description

Stores past solutions in memory.

Subclass of Solution History that stores the solutions and other important vectors in memory.

Author

Vikram Garg

Date

2012

Definition at line 42 of file memory_solution_history.h.

Member Typedef Documentation

list_type

typedef std::list<std::pair<Real, map_type> > libMesh::MemorySolutionHistory::list_type

Definition at line 73 of file memory_solution_history.h.

map_type

typedef std::map<std::string, std::unique_ptr<NumericVector<Number> > > libMesh::MemorySolutionHistory::map_type

Typedef for Stored Solutions iterator, a list of pairs of the current system time, map of strings and saved vectors

Definition at line 72 of file memory_solution_history.h.

stored_solutions_iterator

typedef list_type::iterator libMesh::MemorySolutionHistory::stored_solutions_iterator

Definition at line 74 of file memory_solution_history.h.

Constructor & Destructor Documentation

MemorySolutionHistory()

libMesh::MemorySolutionHistory::MemorySolutionHistory ( System &  system_ )

inline

Constructor, reference to system to be passed by user, set the stored_sols iterator to some initial value

Definition at line 50 of file memory_solution_history.h.

                                          : stored_sols(stored_solutions.end()), _system(system_)
  { libmesh_experimental(); }

~MemorySolutionHistory()

libMesh::MemorySolutionHistory::~MemorySolutionHistory

(

)

Destructor

Definition at line 26 of file memory_solution_history.C.

{
}

Member Function Documentation

clone()

virtual std::unique_ptr<SolutionHistory > libMesh::MemorySolutionHistory::clone ( ) const

inlineoverridevirtual

Definition of the clone function needed for the setter function

Implements libMesh::SolutionHistory.

Definition at line 79 of file memory_solution_history.h.

References _system.

  {
    return libmesh_make_unique<MemorySolutionHistory>(_system);
  }

find_stored_entry()

void libMesh::MemorySolutionHistory::find_stored_entry ( )

private

Definition at line 32 of file memory_solution_history.C.

References _system, std::abs(), stored_sols, stored_solutions, libMesh::System::time, and libMesh::TOLERANCE.

Referenced by retrieve(), and store().

{
  if (stored_solutions.begin() == stored_solutions.end())
    return;

  libmesh_assert (stored_sols != stored_solutions.end());

  if (std::abs(stored_sols->first - _system.time) < TOLERANCE)
    return;

  // If we're not at the front, check the previous entry
  if (stored_sols != stored_solutions.begin())
    {
      stored_solutions_iterator test_it = stored_sols;
      if (std::abs((--test_it)->first - _system.time) < TOLERANCE)
        {
          --stored_sols;
          return;
        }
    }

  // If we're not at the end, check the subsequent entry
  stored_solutions_iterator test_it = stored_sols;
  if ((++test_it) != stored_solutions.end())
    {
      if (std::abs(test_it->first - _system.time) < TOLERANCE)
        {
          ++stored_sols;
          return;
        }
    }
}

retrieve()

void libMesh::MemorySolutionHistory::retrieve ( )

overridevirtual

Virtual function retrieve which we will be overriding to retrieve timesteps

Implements libMesh::SolutionHistory.

Definition at line 129 of file memory_solution_history.C.

References _system, std::abs(), find_stored_entry(), libMesh::System::get_vector(), libMesh::Real, libMesh::System::solution, stored_sols, stored_solutions, libMesh::System::time, and libMesh::TOLERANCE.

{
  this->find_stored_entry();

  // Get the time at which we are recovering the solution vectors
  Real recovery_time = stored_sols->first;

  // Print out what time we are recovering vectors at
  //    libMesh::out << "Recovering solution vectors at time: " <<
  //                 recovery_time << std::endl;

  // Do we not have a solution for this time?  Then
  // there's nothing to do.
  if (stored_sols == stored_solutions.end() ||
      std::abs(recovery_time - _system.time) > TOLERANCE)
    {
      //libMesh::out << "No more solutions to recover ! We are at time t = " <<
      //                     _system.time << std::endl;
      return;
    }

  // Get the saved vectors at this timestep
  map_type & saved_vectors = stored_sols->second;

  map_type::iterator vec = saved_vectors.begin();
  map_type::iterator vec_end = saved_vectors.end();

  // Loop over all the saved vectors
  for (; vec != vec_end; ++vec)
    {
      // The name of this vector
      const std::string & vec_name = vec->first;

      // Get the vec_name entry in the saved vectors map and set the
      // current system vec[vec_name] entry to it
      if (vec_name != "_solution")
        _system.get_vector(vec_name) = *(vec->second);
    }

  // Of course, we will *always* have to get the actual solution
  std::string _solution("_solution");
  *(_system.solution) = *(saved_vectors[_solution]);
}

set_overwrite_previously_stored()

void libMesh::SolutionHistory::set_overwrite_previously_stored ( bool  val )

inlineinherited

Turn on overwrite_previously_stored to overwrite any already-saved data encountered during subsequent store() calls

Definition at line 70 of file solution_history.h.

References libMesh::SolutionHistory::overwrite_previously_stored.

  { overwrite_previously_stored = val; }

store()

void libMesh::MemorySolutionHistory::store ( )

overridevirtual

Virtual function store which we will be overriding to store timesteps

Implements libMesh::SolutionHistory.

Definition at line 67 of file memory_solution_history.C.

References _system, std::abs(), find_stored_entry(), libMesh::SolutionHistory::overwrite_previously_stored, libMesh::System::project_solution_on_reinit(), libMesh::System::solution, stored_sols, stored_solutions, libMesh::System::time, libMesh::TOLERANCE, libMesh::System::vector_preservation(), libMesh::System::vectors_begin(), and libMesh::System::vectors_end().

{
  this->find_stored_entry();

  // In an empty history we create the first entry
  if (stored_solutions.begin() == stored_solutions.end())
    {
      stored_solutions.push_back(std::make_pair(_system.time, map_type()));
      stored_sols = stored_solutions.begin();
    }

  // If we're past the end we can create a new entry
  if (_system.time - stored_sols->first > TOLERANCE )
    {
#ifndef NDEBUG
      ++stored_sols;
      libmesh_assert (stored_sols == stored_solutions.end());
#endif
      stored_solutions.push_back(std::make_pair(_system.time, map_type()));
      stored_sols = stored_solutions.end();
      --stored_sols;
    }

  // If we're before the beginning we can create a new entry
  else if (stored_sols->first - _system.time > TOLERANCE)
    {
      libmesh_assert (stored_sols == stored_solutions.begin());
      stored_solutions.push_front(std::make_pair(_system.time, map_type()));
      stored_sols = stored_solutions.begin();
    }

  // We don't support inserting entries elsewhere
  libmesh_assert(std::abs(stored_sols->first - _system.time) < TOLERANCE);

  // Map of stored vectors for this solution step
  std::map<std::string, std::unique_ptr<NumericVector<Number>>> & saved_vectors = stored_sols->second;

  // Loop over all the system vectors
  for (System::vectors_iterator vec = _system.vectors_begin(); vec != _system.vectors_end(); ++vec)
    {
      // The name of this vector
      const std::string & vec_name = vec->first;

      // If we haven't seen this vector before or if we have and
      // want to overwrite it
      if ((overwrite_previously_stored || !saved_vectors.count(vec_name)) &&
          // and if we think it's worth preserving
          _system.vector_preservation(vec_name))
        {
          // Then we save it.
          saved_vectors[vec_name] = vec->second->clone();
        }
    }

  // Of course, we will usually save the actual solution
  std::string _solution("_solution");
  if ((overwrite_previously_stored || !saved_vectors.count(_solution)) &&
      // and if we think it's worth preserving
      _system.project_solution_on_reinit())
    saved_vectors[_solution] = _system.solution->clone();
}

Member Data Documentation

_system

System& libMesh::MemorySolutionHistory::_system

private

Definition at line 97 of file memory_solution_history.h.

Referenced by clone(), find_stored_entry(), retrieve(), and store().

overwrite_previously_stored

bool libMesh::SolutionHistory::overwrite_previously_stored

protectedinherited

Definition at line 77 of file solution_history.h.

Referenced by libMesh::SolutionHistory::set_overwrite_previously_stored(), and store().

stored_sols

stored_solutions_iterator libMesh::MemorySolutionHistory::stored_sols

private

Definition at line 91 of file memory_solution_history.h.

Referenced by find_stored_entry(), retrieve(), and store().

stored_solutions

list_type libMesh::MemorySolutionHistory::stored_solutions

private

Definition at line 88 of file memory_solution_history.h.

Referenced by find_stored_entry(), retrieve(), and store().

---

The documentation for this class was generated from the following files:

• memory_solution_history.h
• memory_solution_history.C