libMesh::MemorySolutionHistory Class Reference

Subclass of Solution History that stores the solutions and other important vectors 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

Public Member Functions
	MemorySolutionHistory (DifferentiableSystem &system_)
	Constructor, reference to system to be passed by user, set the stored_sols iterator to some initial value.
	~MemorySolutionHistory ()
	Destructor.
virtual void	store (bool is_adjoint_solve, Real time) override
	Virtual function store which we will be overriding to store timesteps.
virtual void	retrieve (bool is_adjoint_solve, Real time) override
	Virtual function retrieve which we will be overriding to retrieve timesteps.
virtual std::unique_ptr< SolutionHistory >	clone () const override
	Definition of the clone function needed for the setter function.
void	erase (Real time)
	Erase stored_data entry at time.
void	set_overwrite_previously_stored (bool val)
	Turn on overwrite_previously_stored to overwrite any already-saved data encountered during subsequent store() calls.

Protected Types
typedef map_type::iterator	stored_data_iterator

Protected Member Functions
void	find_stored_entry (Real time, bool storing=false)

Protected Attributes
bool	overwrite_previously_stored
map_type	stored_data
stored_data_iterator	stored_datum

Private Attributes
DifferentiableSystem &	_system

Detailed Description

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

Author

Vikram Garg

Date

2012

Stores past solutions in memory.

Definition at line 43 of file memory_solution_history.h.

Member Typedef Documentation

map_type

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

Definition at line 69 of file memory_solution_history.h.

stored_data_iterator

typedef map_type::iterator libMesh::SolutionHistory::stored_data_iterator

protectedinherited

Definition at line 95 of file solution_history.h.

Constructor & Destructor Documentation

MemorySolutionHistory()

libMesh::MemorySolutionHistory::MemorySolutionHistory ( DifferentiableSystem &  system_ )

inline

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

Definition at line 51 of file memory_solution_history.h.

                                                        : SolutionHistory(), _system(system_)
  { libmesh_experimental(); }

~MemorySolutionHistory()

libMesh::MemorySolutionHistory::~MemorySolutionHistory

(

)

Destructor.

Definition at line 30 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 74 of file memory_solution_history.h.

  {
    return std::make_unique<MemorySolutionHistory>(_system);
  }

References _system.

erase()

void libMesh::SolutionHistory::erase ( Real  time )

inherited

Erase stored_data entry at time.

Definition at line 95 of file solution_history.C.

 {
  // We cant erase the stored_datum iterator which is used in other places
  // So save its current value for the future
  stored_data_iterator stored_datum_last = stored_datum;
  //std::map<Real, unsigned int>::iterator timeTotimestamp_iterator_last = timeTotimestamp_iterator;
 
  // This will map the stored_datum iterator to the current time
  this->find_stored_entry(time, false);
 
  // map::erase behaviour is undefined if the iterator is pointing
  // to a non-existent element.
  libmesh_assert(stored_datum != stored_data.end());
 
  // We want to keep using the stored_datum iterator, so we have to create
  // a new one to erase the concerned entry
  stored_data_iterator stored_datum_copy = stored_datum;
 
  // If we're asking to erase the entry at stored_datum, then move stored_datum somewhere safer first
  if(stored_datum == stored_datum_last)
    stored_datum--;
 
  stored_data.erase(stored_datum_copy);
 }

References libMesh::SolutionHistory::find_stored_entry(), libMesh::libmesh_assert(), libMesh::SolutionHistory::stored_data, and libMesh::SolutionHistory::stored_datum.

find_stored_entry()

void libMesh::SolutionHistory::find_stored_entry ( Real  time, bool  storing = false  )

protectedinherited

Definition at line 27 of file solution_history.C.

 {
  if (stored_data.begin() == stored_data.end())
    return;
 
  // We will use the map::lower_bound operation to find the key which
  // is the least upper bound among all existing keys for time.
  // (key before map::lower_bound) < time < map::lower_bound, one of these
  // should be within TOLERANCE of time (unless we are creating a new map entry)
  // If the lower bound iterator points to:
  // begin -> we are looking for the solution at the initial time
  // end -> we are creating a new entry
  // anything else, we are looking for an existing entry
  stored_data_iterator lower_bound_it = stored_data.lower_bound(time);
 
  // For the key right before the lower bound
  stored_data_iterator lower_bound_it_decremented;
 
  // If we are at end, we could be creating a new entry (depends on the storing bool), return
  // Otherwise, get a decremented iterator for the sandwich test
  if(lower_bound_it == stored_data.end())
  {
    // If we are storing and lower_bound_it points to stored_data.end(), we assume
    // that this is a brand new entry in the map. We leave stored_datum unchanged.
    if(storing)
    {
      return;
    }
    else
    {
      // We are trying to retrieve and none of the keys was an upper bound.
      // We could have a situation in which the time is greatest key + FPE.
      // So we can check the key before the end and see if it matches time, else we have an error.
      lower_bound_it = std::prev(lower_bound_it);
    }
  }
  else if(lower_bound_it == stored_data.begin()) // At the beginning, so we cant go back any further
  {
    stored_datum = stored_data.begin();
    return;
  }
  else // A decremented iterator, to perform the sandwich test for the key closest to time
  {
    lower_bound_it_decremented = std::prev(lower_bound_it);
  }
 
  // Set the stored sols iterator as per the key which is within TOLERANCE of time
  if(std::abs(lower_bound_it->first - time) < TOLERANCE)
  {
    stored_datum = lower_bound_it;
  }
  else if(std::abs(lower_bound_it_decremented->first - time) < TOLERANCE)
  {
    stored_datum = lower_bound_it_decremented;
  }
  else // Neither of the two candidate keys matched our time
  {
    if(storing) // If we are storing, this is fine, we need to create a new entry, so just return
    {
      return;
    }
    else // If we are not storing, then we expected to find something but didn't, so we have a problem
    {
      libmesh_error_msg("Failed to set stored solutions iterator to a valid value.");
    }
  }
 }

References libMesh::SolutionHistory::stored_data, libMesh::SolutionHistory::stored_datum, and libMesh::TOLERANCE.

Referenced by libMesh::SolutionHistory::erase(), libMesh::FileSolutionHistory::retrieve(), retrieve(), libMesh::FileSolutionHistory::store(), and store().

retrieve()

void libMesh::MemorySolutionHistory::retrieve ( bool  is_adjoint_solve, Real  time  )

overridevirtual

Virtual function retrieve which we will be overriding to retrieve timesteps.

Implements libMesh::SolutionHistory.

Definition at line 87 of file memory_solution_history.C.

{
  this->find_stored_entry(time, false);
 
  // If we are solving the adjoint, the timestep we need to move to the past step
  // is the one taken at that step to get to the current time.
  // At the initial time, be ready for the primal time march again.
  if(is_adjoint_solve)
  {
    if( stored_datum != stored_data.begin() )
    {
      stored_data_iterator stored_datum_past = stored_datum;
      stored_datum_past--;
 
      _system.deltat = (stored_datum_past->second)->get_deltat_at();
    }
    else
    {
      _system.deltat = (stored_datum->second)->get_deltat_at();
    }
  }
  else
  {
    if( stored_datum != std::prev(stored_data.end()) )
      _system.deltat = (stored_datum->second)->get_deltat_at();
    else
    {
      stored_data_iterator stored_datum_past = stored_datum;
      stored_datum_past--;
 
      _system.deltat = (stored_datum_past->second)->get_deltat_at();
    }
 
  }
 
  // Get the time at which we are recovering the solution vectors
  Real recovery_time = stored_datum->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_datum == stored_data.end() ||
      std::abs(recovery_time - time) > TOLERANCE)
    {
      //libMesh::out << "No more solutions to recover ! We are at time t = " <<
      //                     _system.time << std::endl;
      return;
    }
 
  (stored_datum->second)->retrieve_primal_solution();
 
  // We need to call update to put system in a consistent state
  // with the solution that was read in
  _system.update();
}

References _system, libMesh::DifferentiableSystem::deltat, libMesh::SolutionHistory::find_stored_entry(), libMesh::Real, libMesh::SolutionHistory::stored_data, libMesh::SolutionHistory::stored_datum, libMesh::TOLERANCE, and libMesh::System::update().

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 80 of file solution_history.h.

  { overwrite_previously_stored = val; }

References libMesh::SolutionHistory::overwrite_previously_stored.

store()

void libMesh::MemorySolutionHistory::store ( bool  is_adjoint_solve, Real  time  )

overridevirtual

Virtual function store which we will be overriding to store timesteps.

Implements libMesh::SolutionHistory.

Definition at line 36 of file memory_solution_history.C.

{
  this->find_stored_entry(time, true);
 
  // In an empty history we create the first entry
  if (stored_data.begin() == stored_data.end())
    {
      stored_data[time] = std::make_unique<MemoryHistoryData>(_system);
      stored_datum = stored_data.begin();
    }
 
  // If we're past the end we can create a new entry
  if (time - stored_datum->first > TOLERANCE )
    {
#ifndef NDEBUG
      ++stored_datum;
      libmesh_assert (stored_datum == stored_data.end());
#endif
      stored_data[time] = std::make_unique<MemoryHistoryData>(_system);
      stored_datum = stored_data.end();
      --stored_datum;
    }
 
  // If we're before the beginning we can create a new entry
  else if (stored_datum->first - time > TOLERANCE)
    {
      libmesh_assert (stored_datum == stored_data.begin());
      stored_data[time] = std::make_unique<MemoryHistoryData>(_system);
      stored_datum = stored_data.begin();
    }
 
  // We don't support inserting entries elsewhere
  libmesh_assert(std::abs(stored_datum->first - time) < TOLERANCE);
 
  // First we handle the case of the initial data, this is the only case in which
  // stored_data will have size one
  if(stored_data.size() == 1)
  {
    // The initial data should only be stored once.
    (stored_datum->second)->store_initial_solution();
  }
  else if((stored_datum->second)->get_previously_stored() == false) // If we are not at the initial time, we are either creating a new entry or overwriting an existing one
  {
    (stored_datum->second)->store_primal_solution(stored_datum);
  }
  else // We are overwriting an existing history data
  {
    (stored_datum->second)->rewrite_stored_solution();
  }
}

References _system, libMesh::SolutionHistory::find_stored_entry(), libMesh::libmesh_assert(), libMesh::SolutionHistory::stored_data, libMesh::SolutionHistory::stored_datum, and libMesh::TOLERANCE.

Member Data Documentation

_system

DifferentiableSystem& libMesh::MemorySolutionHistory::_system

private

Definition at line 82 of file memory_solution_history.h.

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

overwrite_previously_stored

bool libMesh::SolutionHistory::overwrite_previously_stored

protectedinherited

Definition at line 87 of file solution_history.h.

Referenced by libMesh::SolutionHistory::set_overwrite_previously_stored().

stored_data

map_type libMesh::SolutionHistory::stored_data

protectedinherited

Definition at line 94 of file solution_history.h.

Referenced by libMesh::SolutionHistory::erase(), libMesh::SolutionHistory::find_stored_entry(), libMesh::FileSolutionHistory::retrieve(), retrieve(), libMesh::FileSolutionHistory::store(), and store().

stored_datum

stored_data_iterator libMesh::SolutionHistory::stored_datum

protectedinherited

Definition at line 96 of file solution_history.h.

Referenced by libMesh::SolutionHistory::erase(), libMesh::SolutionHistory::find_stored_entry(), libMesh::FileSolutionHistory::retrieve(), retrieve(), libMesh::FileSolutionHistory::store(), and store().

---

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

• include/solvers/memory_solution_history.h
• src/solvers/memory_solution_history.C