Inheritance diagram for ThetaSolverTestBase< TimeSolverType >:

[legend]

Public Member Functions
	ThetaSolverTestBase ()

	ThetaSolverTestBase ()

Protected Member Functions
virtual void	aux_time_solver_init (TimeSolverType &time_solver)

void	set_theta (Real theta)

virtual void	aux_time_solver_init (TimeSolverType &time_solver)

void	set_theta (Real theta)

template<typename SystemType >
void	run_test_with_exact_soln (Real deltat, unsigned int n_timesteps)

Protected Attributes
Real	_theta

Detailed Description

template<typename TimeSolverType>
class ThetaSolverTestBase< TimeSolverType >

Definition at line 53 of file first_order_unsteady_solver_test.C.

Constructor & Destructor Documentation

◆ ThetaSolverTestBase() [1/2]

template<typename TimeSolverType>

ThetaSolverTestBase< TimeSolverType >::ThetaSolverTestBase ( )

inline

Definition at line 56 of file first_order_unsteady_solver_test.C.

     : TimeSolverTestImplementation<TimeSolverType>(),
     _theta(1.0)
   {}

◆ ThetaSolverTestBase() [2/2]

template<typename TimeSolverType>

ThetaSolverTestBase< TimeSolverType >::ThetaSolverTestBase ( )

inline

Definition at line 133 of file second_order_unsteady_solver_test.C.

     : TimeSolverTestImplementation<TimeSolverType>(),
     _theta(1.0)
   {}

Member Function Documentation

◆ aux_time_solver_init() [1/2]

template<typename TimeSolverType>

virtual void ThetaSolverTestBase< TimeSolverType >::aux_time_solver_init ( TimeSolverType & time_solver )

inlineprotectedvirtual

Reimplemented from TimeSolverTestImplementation< TimeSolverType >.

Definition at line 63 of file first_order_unsteady_solver_test.C.

64 { time_solver.theta = _theta; }

◆ aux_time_solver_init() [2/2]

template<typename TimeSolverType>

virtual void ThetaSolverTestBase< TimeSolverType >::aux_time_solver_init ( TimeSolverType & time_solver )

inlineprotectedvirtual

Reimplemented from TimeSolverTestImplementation< TimeSolverType >.

Definition at line 140 of file second_order_unsteady_solver_test.C.

141 { time_solver.theta = _theta; }

◆ run_test_with_exact_soln()

template<typename TimeSolverType>

template<typename SystemType >

void TimeSolverTestImplementation< TimeSolverType >::run_test_with_exact_soln	(	Real	deltat,
		unsigned int	n_timesteps
	)

inlineprotectedinherited

Definition at line 27 of file time_solver_test_common.h.

   {
     Mesh mesh(*TestCommWorld);
     MeshTools::Generation::build_point(mesh);
     EquationSystems es(mesh);
     SystemType & system = es.add_system<SystemType>("ScalarSystem");
  
     system.time_solver = libmesh_make_unique<TimeSolverType>(system);
  
     es.init();
  
     DiffSolver & solver = *(system.time_solver->diff_solver().get());
     solver.relative_step_tolerance = std::numeric_limits<Real>::epsilon()*10;
     solver.relative_residual_tolerance = std::numeric_limits<Real>::epsilon()*10;
     solver.absolute_residual_tolerance = std::numeric_limits<Real>::epsilon()*10;
  
     NewtonSolver & newton = cast_ref<NewtonSolver &>(solver);
  
     // LASPACK GMRES + ILU defaults don't like these problems, so
     // we'll use a sophisticated "just divide the scalars" solver instead.
     newton.get_linear_solver().set_solver_type(JACOBI);
     newton.get_linear_solver().set_preconditioner_type(IDENTITY_PRECOND);
  
     system.deltat = deltat;
  
     TimeSolverType * time_solver = cast_ptr<TimeSolverType *>(system.time_solver.get());
     this->aux_time_solver_init(*time_solver);
  
     // We're going to want to check our solution, and when we run
     // "make check" with LIBMESH_RUN='mpirun -np N" for N>1 then we'll
     // need to keep that check in sync with the processors that are just
     // twiddling their thumbs, not owning our mesh point.
     std::vector<dof_id_type> solution_index;
     solution_index.push_back(0);
     const bool has_solution = system.get_dof_map().all_semilocal_indices(solution_index);
  
     for (unsigned int t_step=0; t_step != n_timesteps; ++t_step)
       {
         system.solve();
         system.time_solver->advance_timestep();
  
         Real rel_error = 0;
  
         if (has_solution)
           {
             Number exact_soln = system.u(system.time);
             rel_error =  std::abs((exact_soln - (*system.solution)(0))/exact_soln);
           }
         system.comm().max(rel_error);
  
         // Using relative error for comparison, so "exact" is 0
         LIBMESH_ASSERT_FP_EQUAL( 0.0,
                                  rel_error,
                                  std::numeric_limits<Real>::epsilon()*10 );
       }
   }