libMesh::FileSolutionHistory Class Reference

Subclass of Solution History that stores the solutions and other important vectors onto disk. More...

#include <file_solution_history.h>

Inheritance diagram for libMesh::FileSolutionHistory:

Public Member Functions
	FileSolutionHistory (DifferentiableSystem &system)
	Constructor, reference to system to be passed by user, set the stored_sols iterator to some initial value.
	~FileSolutionHistory ()
	Destructor, defaulted out-of-line.
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 std::map< Real, std::unique_ptr< HistoryData > >	map_type
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
std::vector< std::unique_ptr< NumericVector< Number > > >	dual_solution_copies
	A vector of pointers to adjoint and old adjoint solutions at the last time step.
std::vector< std::unique_ptr< NumericVector< Number > > >	old_dual_solution_copies

Detailed Description

Subclass of Solution History that stores the solutions and other important vectors onto disk.

Author

Vikram Garg

Date

2020

Stores past solutions onto disk.

Definition at line 46 of file file_solution_history.h.

Member Typedef Documentation

map_type

typedef std::map<Real, std::unique_ptr<HistoryData> > libMesh::SolutionHistory::map_type

protectedinherited

Definition at line 93 of file 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

FileSolutionHistory()

libMesh::FileSolutionHistory::FileSolutionHistory

(

DifferentiableSystem &

system

)

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

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

Definition at line 36 of file file_solution_history.C.

  : SolutionHistory(), _system(system)
{
  dual_solution_copies.resize(_system.n_qois());
  old_dual_solution_copies.resize(_system.n_qois());
 
  libmesh_experimental();
}

References _system, dual_solution_copies, libMesh::System::n_qois(), and old_dual_solution_copies.

~FileSolutionHistory()

libMesh::FileSolutionHistory::~FileSolutionHistory ( )

default

Destructor, defaulted out-of-line.

Member Function Documentation

clone()

std::unique_ptr< SolutionHistory > libMesh::FileSolutionHistory::clone ( ) const

overridevirtual

Definition of the clone function needed for the setter function.

Implements libMesh::SolutionHistory.

Definition at line 49 of file file_solution_history.C.

{
  return std::make_unique<FileSolutionHistory>(_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(), retrieve(), libMesh::MemorySolutionHistory::retrieve(), store(), and libMesh::MemorySolutionHistory::store().

retrieve()

void libMesh::FileSolutionHistory::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 116 of file file_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;
 
  // 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;
    }
 
 
  // If we are doing an adjoint solve, we read in the primal solution,
  // but this overwrites the adjoint solution with zero, so we swap
  // the last adjoint solution out to prevent this zeroing
  if(is_adjoint_solve)
  {
    // Reading in the primal xdas overwrites the adjoint solution with zero
    // So swap to retain the adjoint and old adjoint vectors
    for (auto j : make_range(_system.n_qois()))
    {
      dual_solution_copies[j] = _system.get_adjoint_solution(j).clone();
 
      std::string old_adjoint_solution_name = "_old_adjoint_solution";
      old_adjoint_solution_name+= std::to_string(j);
      old_dual_solution_copies[j] = _system.get_vector(old_adjoint_solution_name).clone();
    }
 
    // Read in the primal solution stored at the current recovery time from the disk
    (stored_datum->second)->retrieve_primal_solution();
 
    // Swap back the copy of adjoint and old adjoint vectors back in place
    for (auto j : make_range(_system.n_qois()))
    {
      (_system.get_adjoint_solution(j)).swap(*dual_solution_copies[j]);
 
      std::string old_adjoint_solution_name = "_old_adjoint_solution";
      old_adjoint_solution_name+= std::to_string(j);
      (_system.get_vector(old_adjoint_solution_name)).swap(*old_dual_solution_copies[j]);
    }
  }
  else
  {
    // // If we are not in the adjoint loop, we could be in the primal loop again having solved
    // // only the primal problem, or in a primal postprocessing stage to evaluate a QoI for example.
    // // If we can find an adjoint solution file, read that in, else read in the primal file
    if(dynamic_cast<FileHistoryData &>(*(stored_datum->second)).get_adjoint_filename().empty())
      (stored_datum->second)->retrieve_primal_solution();
    else
      (stored_datum->second)->retrieve_adjoint_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::NumericVector< T >::clone(), libMesh::DifferentiableSystem::deltat, dual_solution_copies, libMesh::SolutionHistory::find_stored_entry(), libMesh::FileHistoryData::get_adjoint_filename(), libMesh::System::get_adjoint_solution(), libMesh::System::get_vector(), libMesh::make_range(), libMesh::System::n_qois(), old_dual_solution_copies, 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::FileSolutionHistory::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 55 of file file_solution_history.C.

{
  // This will map the stored_datum iterator to the current time
  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<FileHistoryData>(_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<FileHistoryData>(_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<FileHistoryData>(_system);
      stored_datum = stored_data.begin();
    }
 
  // We don't support inserting entries elsewhere
  libmesh_assert(std::abs(stored_datum->first - time) < TOLERANCE);
 
  // If we are in the primal loop, either reuse an existing timestamp if a write has been done for
  // this time earlier. Else, we are at a new time and need to make a new entry in the timeTotimestamp map.
  if(!is_adjoint_solve)
  {
     // 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)
     {
       (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
    {
      (stored_datum->second)->rewrite_stored_solution();
    }
  }
  else // We are in the adjoint time stepping loop
  {
    (stored_datum->second)->store_adjoint_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::FileSolutionHistory::_system

private

Definition at line 79 of file file_solution_history.h.

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

dual_solution_copies

std::vector< std::unique_ptr<NumericVector<Number> > > libMesh::FileSolutionHistory::dual_solution_copies

private

A vector of pointers to adjoint and old adjoint solutions at the last time step.

These are used to prevent the zeroing of the adjoint and old adjoint by es::read.

Definition at line 85 of file file_solution_history.h.

Referenced by FileSolutionHistory(), and retrieve().

old_dual_solution_copies

std::vector< std::unique_ptr<NumericVector<Number> > > libMesh::FileSolutionHistory::old_dual_solution_copies

private

Definition at line 86 of file file_solution_history.h.

Referenced by FileSolutionHistory(), and retrieve().

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(), retrieve(), libMesh::MemorySolutionHistory::retrieve(), store(), and libMesh::MemorySolutionHistory::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(), retrieve(), libMesh::MemorySolutionHistory::retrieve(), store(), and libMesh::MemorySolutionHistory::store().

---

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

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