CppNoddy::PDE_double_IBVP< _Type > Class Template Reference

A templated object for real/complex vector system of unsteady equations. More...

#include <PDE_double_IBVP.h>

Inheritance diagram for CppNoddy::PDE_double_IBVP< _Type >:

Public Member Functions
	PDE_double_IBVP (Equation_3matrix< _Type > *equation_ptr, const DenseVector< double > &xnodes, const DenseVector< double > &ynodes, Residual_with_coords< _Type > *ptr_to_bottom_residual, Residual_with_coords< _Type > *ptr_to_top_residual)
	The class is defined by a vector function for the system. More...
	~PDE_double_IBVP ()
	Destructor. More...
void	update_previous_solution ()
	Copy the current solution to the previous solution. More...
void	step2 (const double &dt)
	A Crank-Nicolson 'time' stepper. More...
double &	t ()
	Return a reference to the current value of the 'timelike' coordinate. More...
double &	tolerance ()
	Return a reference to the convergence tolerance. More...
TwoD_Node_Mesh< _Type > &	solution ()

Detailed Description

template<typename _Type>
class CppNoddy::PDE_double_IBVP< _Type >

A templated object for real/complex vector system of unsteady equations.

Definition at line 44 of file PDE_double_IBVP.h.

Constructor & Destructor Documentation

PDE_double_IBVP()

template<typename _Type >

CppNoddy::PDE_double_IBVP< _Type >::PDE_double_IBVP	(	Equation_3matrix< _Type > *	equation_ptr,
		const DenseVector< double > &	xnodes,
		const DenseVector< double > &	ynodes,
		Residual_with_coords< _Type > *	ptr_to_bottom_residual,
		Residual_with_coords< _Type > *	ptr_to_top_residual
	)

The class is defined by a vector function for the system.

Parameters

equation_ptr	A pointer to an inherited Equation object.
xnodes	A vector that defines the nodal x-positions.
ynodes	A vector that defines the nodal y-positions.
ptr_to_bottom_residual	A pointer to a residual object that defines the y=y1 boundary conditions.
ptr_to_top_residual	A pointer to a residual object that defines the y=y2 boundary conditions.

Definition at line 18 of file PDE_double_IBVP.cpp.

                                                      :
    TOL(1.e-8),
    T(0.0),
    MAX_ITERATIONS(20),
    p_EQUATION(ptr_to_equation),
    p_BOTTOM_RESIDUAL(ptr_to_bottom_residual),
    p_TOP_RESIDUAL(ptr_to_top_residual),
    UPDATED(false) {
    // create the 2D mesh for the current time level and previous time level
    SOLN = TwoD_Node_Mesh<_Type>(xnodes, ynodes, p_EQUATION -> get_order());
    // copy construct the previous solution's storage
    PREV_SOLN = SOLN;
    // initialise the eqn object
    // "x"
    p_EQUATION -> coord(2) = xnodes[0];
#ifdef TIME
    // timers
    T_ASSEMBLE = Timer("Assembling of the matrix (incl. equation updates):");
    T_SOLVE = Timer("Solving of the matrix:");
#endif
  }

~PDE_double_IBVP()

template<typename _Type >

CppNoddy::PDE_double_IBVP< _Type >::~PDE_double_IBVP

Destructor.

Definition at line 46 of file PDE_double_IBVP.cpp.

                                           {
#ifdef TIME
    std::cout << "\n";
    T_ASSEMBLE.stop();
    T_ASSEMBLE.print();
    T_SOLVE.stop();
    T_SOLVE.print();
#endif
  }

Member Function Documentation

solution()

template<typename _Type >

TwoD_Node_Mesh< _Type > & CppNoddy::PDE_double_IBVP< _Type >::solution

inline

Returns

A handle to the solution mesh

Definition at line 123 of file PDE_double_IBVP.h.

                                                                 {
    return SOLN;
  }

Referenced by main().

step2()

template<typename _Type >

void CppNoddy::PDE_double_IBVP< _Type >::step2

(

const double &

dt

)

A Crank-Nicolson 'time' stepper.

Definition at line 57 of file PDE_double_IBVP.cpp.

                                                     {
    DT = dt;
    if(!UPDATED) {
      std::string problem;
      problem = " You have called the PDE_double_IBVP::step2 method without calling\n";
      problem += " the PDE_double_IBVP::update_previous_solution method first. This\n";
      problem += " method is required to copy/store the previous time level's solution\n";
      problem += " and then allow you to specify/alter the x-initial condition by\n";
      problem += " for the current time level.";
      throw ExceptionRuntime(problem);
    }
    // the order of the problem
    unsigned order(p_EQUATION -> get_order());
    // get the number of nodes in the mesh
    // -- this may have been refined by the user since the last call.
    unsigned nx(SOLN.get_nnodes().first);
    unsigned ny(SOLN.get_nnodes().second);
    // measure of maximum residual
    double max_residual(1.0);
    // the current solution moves to the previous solution
    // ANY LARGE STORAGE USED IN THE MAIN LOOP IS
    // DEFINED HERE TO AVOID REPEATED CONSTRUCTION.
    // Note we blank the A matrix after every iteration.
    //
    // Banded LHS matrix - max obove diagonal band wTidth is
    // from first variable at node i to last variable at node i+1
    BandedMatrix<_Type> a(ny * order, 2 * order - 1, 0.0);
    // RHS
    DenseVector<_Type> b(ny * order, 0.0);
    // linear solver definition
#ifdef LAPACK
    BandedLinearSystem<_Type> system(&a, &b, "lapack");
#else
    BandedLinearSystem<_Type> system(&a, &b, "native");
#endif
    for(std::size_t j = 0; j < nx - 1; ++j) {
      //// next x-soln guess is the previous x-soln
      //for ( std::size_t var = 0; var < order; ++var )
      //{
      //for ( std::size_t i = 0; i < ny; ++i )
      //{
      //SOLN( j + 1, i, var ) = SOLN( j, i, var );
      //}
      //}
      //
      // iteration counter
      int counter = 0;
      // loop until converged or too many iterations
      do {
        // iteration counter
        ++counter;
        // time the assemble phase
#ifdef TIME
        T_ASSEMBLE.start();
#endif
        assemble_matrix_problem(a, b, j);
        max_residual = b.inf_norm();
#ifdef DEBUG
        std::cout.precision(12);
        std::cout << " PDE_double_IBVP.step2 : x_j = " << SOLN.coord(j,0).first << " Residual_max = " << max_residual << " tol = " << TOL << " counter = " << counter << "\n";
#endif
#ifdef TIME
        T_ASSEMBLE.stop();
        T_SOLVE.start();
#endif
        // linear solver
        system.solve();
        // keep the solution in a OneD_GenMesh object
        for(std::size_t i = 0; i < ny; ++i) {
          for(std::size_t var = 0; var < order; ++var) {
            SOLN(j + 1, i, var) += b[ i * order + var ];
          }
        }
#ifdef TIME
        T_SOLVE.stop();
#endif
      } while((max_residual > TOL) && (counter < MAX_ITERATIONS));
      if(counter >= MAX_ITERATIONS) {
        std::string problem("\n The PDE_double_IBVP.step2 method took too many iterations. \n");
        throw ExceptionItn(problem, counter, max_residual);
      }
    }
    // set the time to the updated level
    T += DT;
#ifdef DEBUG
    std::cout << "[DEBUG] solved at t = " << T << "\n";
#endif
    UPDATED = false;
  }

References CppNoddy::DenseVector< _Type >::inf_norm(), and CppNoddy::BandedLinearSystem< _Type >::solve().

Referenced by main().

t()

template<typename _Type >

double & CppNoddy::PDE_double_IBVP< _Type >::t

inline

Return a reference to the current value of the 'timelike' coordinate.

Returns

A handle to the current timelinke coordinate stored in the object

Definition at line 128 of file PDE_double_IBVP.h.

                                           {
    return T;
  }

Referenced by main().

tolerance()

template<typename _Type >

double & CppNoddy::PDE_double_IBVP< _Type >::tolerance ( )

inline

Return a reference to the convergence tolerance.

Definition at line 76 of file PDE_double_IBVP.h.

                        {
      return TOL;
    }

update_previous_solution()

template<typename _Type >

void CppNoddy::PDE_double_IBVP< _Type >::update_previous_solution ( )

inline

Copy the current solution to the previous solution.

Definition at line 63 of file PDE_double_IBVP.h.

                                    {
      PREV_SOLN = SOLN;
      UPDATED = true;
    }

Referenced by main().

---

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

• include/PDE_double_IBVP.h
• src/PDE_double_IBVP.cpp