Index: include/solvers/time_solver.h =================================================================== --- include/solvers/time_solver.h (revision 6367) +++ include/solvers/time_solver.h (working copy) @@ -26,6 +26,7 @@ #include "libmesh/linear_solver.h" #include "libmesh/numeric_vector.h" #include "libmesh/reference_counted_object.h" +#include "libmesh/solution_history.h" // C++ includes @@ -109,7 +110,7 @@ * timestep, after an adjoint_solve() has been performed. This will * probably be done after every UnsteadySolver::adjoint_solve(). */ - virtual void adjoint_recede_timestep (); + virtual void adjoint_advance_timestep (); /** * This method uses the DifferentiableSystem's @@ -190,6 +191,12 @@ */ unsigned int reduce_deltat_on_diffsolver_failure; + /** + * A setter function users will user if they need to do something + * other than have no solution history + */ + void set_solution_history(const SolutionHistory & _solution_history); + protected: /** @@ -217,6 +224,13 @@ * Serial vector of _system.get_vector("_old_nonlinear_solution") */ AutoPtr > old_local_nonlinear_solution; + + /** + * An AutoPtr to a SolutionHistory object. Default is + * NoSolutionHistory, which the user can override by declaring a + * different kind of SolutionHistory in the application + */ + AutoPtr solution_history; }; Index: include/solvers/solution_history.h =================================================================== --- include/solvers/solution_history.h (revision 0) +++ include/solvers/solution_history.h (revision 0) @@ -0,0 +1,38 @@ +// A SolutionHistory class that enables the storage and retrieval of timesteps +// and in the future adaptive steps + +#ifndef __solution_history_h__ +#define __solution_history_h__ + +// Local Includes +#include "libmesh/system.h" + +namespace libMesh +{ + + // SolutionHistory class declaration and definition + class SolutionHistory + { + public: + + // Constructor + SolutionHistory() {}; + + // Destructor + ~SolutionHistory () {}; + + // Function to store a solution, pure virtual + virtual void store() = 0; + + // Function to retrieve a solution, pure virtual + virtual void retrieve() = 0; + + // Cloning function for an AutoPtr, pure virtual, used in the + // setter function in time_solver.C + virtual AutoPtr clone() const = 0; + + }; // end SolutionHistory class definition + +} // end namespace libMesh + +#endif // __solution_history_h__ Index: include/solvers/memory_solution_history.h =================================================================== --- include/solvers/memory_solution_history.h (revision 0) +++ include/solvers/memory_solution_history.h (revision 0) @@ -0,0 +1,54 @@ +// Subclass of Solution History that stores the solutions in memory + +#ifndef __memory_solution_history_h__ +#define __memory_solution_history_h__ + +// Local includes +#include "libmesh/numeric_vector.h" +#include "libmesh/solution_history.h" +#include + +namespace libMesh +{ + + // MemorySolutionHistory class declaration and definition + class MemorySolutionHistory : public SolutionHistory + { + public: + + // Constructor, reference to system to be passed by user, set the + // stored_sols iterator to some initial value + MemorySolutionHistory(System & system_) : stored_sols(stored_solutions.end()), _system(system_) {} ; + + // Virtual function store which we will be overriding to store timesteps + virtual void store(); + + // Virtual function retrieve which we will be overriding to retrieve timesteps + virtual void retrieve(); + + // Typedef for Stored Solutions iterator, a list of pairs of the current + // system time, map of strings and saved vectors + typedef std::list*> > >::iterator stored_solutions_iterator; + + // Definition of the clone function needed for the setter function + virtual AutoPtr clone() const { + return AutoPtr + (new MemorySolutionHistory(_system));} + + private: + + // This list of pairs will hold the current time and stored vectors + // from each timestep + std::list*> > > stored_solutions; + + // The stored solutions iterator + stored_solutions_iterator stored_sols; + + // A system reference + System & _system ; + + }; + +} // end namespace libMesh + +#endif // __memory_solution_history_h__ Index: include/solvers/no_solution_history.h =================================================================== --- include/solvers/no_solution_history.h (revision 0) +++ include/solvers/no_solution_history.h (revision 0) @@ -0,0 +1,38 @@ +// 'Do nothing' subclass of Solution History + +#ifndef __no_solution_history_h__ +#define __no_solution_history_h__ + +// Local includes +#include "libmesh/solution_history.h" + +namespace libMesh +{ + + // NoSolutionHistory class declaration and definition + class NoSolutionHistory : public SolutionHistory + { + public: + + // Constructor + NoSolutionHistory() : SolutionHistory() {}; + + // Destructor + ~NoSolutionHistory() {}; + + // Virtual function store which we will be overriding + virtual void store(); + + // Virtual function retrieve which we will be overriding + virtual void retrieve(); + + // Definition of the clone function needed for the setter function + virtual AutoPtr clone() const { + return AutoPtr + (new NoSolutionHistory());} + + }; // end NoSolutionHistory class definition + +} // end namespace libMesh + +#endif // __no_solution_history_h__ Index: src/solvers/time_solver.C =================================================================== --- src/solvers/time_solver.C (revision 6367) +++ src/solvers/time_solver.C (working copy) @@ -15,11 +15,11 @@ // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - #include "libmesh/diff_solver.h" #include "libmesh/diff_system.h" #include "libmesh/linear_solver.h" #include "libmesh/time_solver.h" +#include "libmesh/no_solution_history.h" namespace libMesh { @@ -31,7 +31,8 @@ reduce_deltat_on_diffsolver_failure (0), _diff_solver (NULL), _linear_solver (NULL), - _system (s) + _system (s), + solution_history(new NoSolutionHistory()) // Default setting for solution_history { } @@ -80,6 +81,10 @@ } +void TimeSolver::set_solution_history (const SolutionHistory & _solution_history) + { + solution_history = _solution_history.clone(); + } void TimeSolver::advance_timestep () { @@ -87,7 +92,7 @@ -void TimeSolver::adjoint_recede_timestep () +void TimeSolver::adjoint_advance_timestep () { } Index: src/solvers/memory_solution_history.C =================================================================== --- src/solvers/memory_solution_history.C (revision 0) +++ src/solvers/memory_solution_history.C (revision 0) @@ -0,0 +1,81 @@ +// Function definitions for MemorySolutionHistory + +// Local includes +#include "libmesh/memory_solution_history.h" + +namespace libMesh +{ + // This functions saves all the 'projection-worthy' system vectors for + // future use + void MemorySolutionHistory::store() + { + // Increment the stored_sols iterator + ++stored_sols; + + // Map of to be projected vectors from this solution step + std::map *> saved_vectors; + + // 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; + + // Check if this vector is to be projected + bool vector_projection_setting = _system.vector_preservation(vec_name); + + // If it is important enough to be projected, it is important enough to be saved + if(vector_projection_setting) + { + saved_vectors[vec_name] = vec->second->clone().release(); + } + + } + + // Of course, we also have to save the actual solution + std::string _solution("_solution"); + + // Save the solution + saved_vectors[_solution] = _system.solution->clone().release(); + + // Put all the vectors from this timestep into stored_solutions + stored_solutions.push_back(std::make_pair(_system.time, saved_vectors)); + + } + + void MemorySolutionHistory::retrieve() + { + // To find the required solution, we need to first decrement the stored_sols iterator + --stored_sols; + + // Get the saved vectors at this timestep + std::map *> 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; + + // Check if this vector was projected + bool vector_projection_setting = _system.vector_preservation(vec_name); + + // If it was important enough to be projected, it was important enough to be saved + if(vector_projection_setting) + { + vec->second = saved_vectors[vec_name]; + } + + } + + // Of course, we also have to get the actual solution + std::string _solution("_solution"); + + // Set the system solution vector to the primal solution at this time + _system.solution.reset(); + *(_system.solution) = *(saved_vectors[_solution]); + + } + +} + Index: src/solvers/no_solution_history.C =================================================================== --- src/solvers/no_solution_history.C (revision 0) +++ src/solvers/no_solution_history.C (revision 0) @@ -0,0 +1,20 @@ +// Function Definitions for NoTimeHistory + +// Local includes +#include "libmesh/no_solution_history.h" + +namespace libMesh +{ + + void NoSolutionHistory::store() + { + // Do nothing + } + + void NoSolutionHistory::retrieve() + { + // Nothing was stored, so nothing can be retrieved + libmesh_error(); + } + +}