CppNoddy::ODE_EVP< _Type > Class Template Reference

A templated object for real/complex vector system of first-order ordinary differential equations. More...

#include <ODE_EVP.h>

Inheritance diagram for CppNoddy::ODE_EVP< _Type >:

Public Member Functions
	ODE_EVP (Equation_2matrix< _Type > *equation_ptr, const DenseVector< double > &nodes, Residual< _Type > *ptr_to_left_residual, Residual< _Type > *ptr_to_right_residual)
	The class is defined by a vector function for the system. More...
	~ODE_EVP ()
	Destructor. More...
void	eigensolve ()
	Formulate and solve the global eigenvalue problem for a linear system. More...
LinearEigenSystem_base *	p_eigensystem ()
	Allow access to the underlying dense linear eigensystem through a pointer to the private member data. More...
void	add_tagged_to_mesh ()
OneD_Node_Mesh< D_complex >	get_mesh (const unsigned &i) const

Detailed Description

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

A templated object for real/complex vector system of first-order ordinary differential equations.

Definition at line 35 of file ODE_EVP.h.

Constructor & Destructor Documentation

ODE_EVP()

template<typename _Type >

CppNoddy::ODE_EVP< _Type >::ODE_EVP	(	Equation_2matrix< _Type > *	equation_ptr,
		const DenseVector< double > &	nodes,
		Residual< _Type > *	ptr_to_left_residual,
		Residual< _Type > *	ptr_to_right_residual
	)

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

Parameters

equation_ptr	A pointer to an equation with 2 associated matrices; matrix1 will define the eigenvalue problem.
nodes	A vector of nodal points.
ptr_to_left_residual	A pointer to a residual object that defines the LHS boundary conditions.
ptr_to_right_residual	A pointer to a residual object that defines the RHS boundary conditions.

Definition at line 26 of file ODE_EVP.cpp.

                                                                  :
    p_EQUATION(ptr_to_equation),
    p_LEFT_RESIDUAL(ptr_to_left_residual),
    p_RIGHT_RESIDUAL(ptr_to_right_residual),
    NODES(nodes) {
    unsigned n(nodes.size());
    unsigned order(p_EQUATION -> get_order());
    // first make the dense matrix equivalent of the problem
    // using the Dense( banded ) constructor
    p_A_DENSE = new DenseMatrix<_Type>(n * order, n * order, 0.0);
    p_B_DENSE = new DenseMatrix<_Type>(n * order, n * order, 0.0);
    // point the system pointer to the dense problem
    p_SYSTEM = new DenseLinearEigenSystem<_Type>(p_A_DENSE, p_B_DENSE);
  }

References CppNoddy::DenseVector< _Type >::size().

~ODE_EVP()

template<typename _Type >

CppNoddy::ODE_EVP< _Type >::~ODE_EVP

Destructor.

Definition at line 45 of file ODE_EVP.cpp.

                           {
    // clean up the matrices & evp system
    delete p_SYSTEM;
    delete p_A_DENSE;
    delete p_B_DENSE;
  }

Member Function Documentation

add_tagged_to_mesh()

template<typename _Type >

void CppNoddy::ODE_EVP< _Type >::add_tagged_to_mesh ( )

inline

Definition at line 60 of file ODE_EVP.h.

                              {
      // clear the existing data if any
      MESHES.clear();
      // order of the equation
      unsigned order = p_EQUATION -> get_order();
      // get the eigenvalues
      DenseVector<D_complex> vals(p_SYSTEM -> get_tagged_eigenvalues());
      // get the eigenvectors
      DenseMatrix<D_complex> vecs(p_SYSTEM -> get_tagged_eigenvectors());
      // loop through the eigenvectors
      for(unsigned ivec = 0; ivec < vals.size(); ++ivec) {
        // make a mesh with the right node distribution
        // we'll increase the order by 1 to allow the eigenvalue to be
        // stored at each nodal point -- this is wasteful but very useful
        // for feeding this into a BVP for local refinement.
        OneD_Node_Mesh<D_complex> eigfn(NODES, order + 1);
        // loop through all nodes
        for(unsigned node = 0; node < NODES.size(); ++node) {
          // complex vector of the dof at this node ( + 1 for the eigenvalue)
          DenseVector<D_complex> vars_at_node(order + 1, 0.0);
          // get the dof from the eigenvector
          for(unsigned var = 0; var < order; ++var) {
            vars_at_node[ var ] = vecs[ ivec ][ node * order + var ];
          }
          // the last variable at each node is the corresponding eigenvalue
          vars_at_node[ order ] = vals[ ivec ];
          // set the first 'order' dof to be those from the eigenvector
          eigfn.set_nodes_vars(node, vars_at_node);
        }
        //// store the eigenvalue in the mesh at each node ... wasteful, but useful
        //// a complex vector filled with the same value N times
        //DenseVector<D_complex> c( NODES.size(), vals[ ivec ] );
        //// add it to the mesh -- for use in nonlinear local refinement via ODE_BVP
        //eigfn.push_var( c );
        // add the eigenfunction to the vector of meshes
        MESHES.push_back(eigfn);
      }
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::set_nodes_vars(), and CppNoddy::DenseVector< _Type >::size().

Referenced by main(), and CppNoddy::Example::Neutral_residual::Neutral_residual().

eigensolve()

template<typename _Type >

void CppNoddy::ODE_EVP< _Type >::eigensolve

Formulate and solve the global eigenvalue problem for a linear system.

Definition at line 58 of file ODE_EVP.cpp.

                                  {
    // NOTE: moving construct_banded_system to the constructor is a bad idea, because
    // sometimes we will want to construct an EVP that depends on an
    // underlying baseflow solution that is unknown at the time of construction.
    //
    // construct the banded matrix eigenvalue problem that corresponds
    // to the equation & boundary conditions specified in the constructor.
    assemble_dense_problem();
    // solve the system
    p_SYSTEM -> eigensolve();
  }

Referenced by main(), and CppNoddy::Example::Neutral_residual::Neutral_residual().

get_mesh()

template<typename _Type >

OneD_Node_Mesh< D_complex > CppNoddy::ODE_EVP< _Type >::get_mesh ( const unsigned &  i ) const

inline

Definition at line 99 of file ODE_EVP.h.

                                                                {
#ifdef PARANOID
      if(i > MESHES.size()) {
        std::string problem;
        problem = "You have tried to extract an eigenfunction from the ODE_EVP class\n";
        problem += "whose index is outside the range of stored meshes.\n";
        throw ExceptionRange(problem, MESHES.size(), i);
      }
#endif
      return MESHES[ i ];
    }

Referenced by main(), and CppNoddy::Example::Neutral_residual::Neutral_residual().

p_eigensystem()

template<typename _Type >

LinearEigenSystem_base * CppNoddy::ODE_EVP< _Type >::p_eigensystem

Allow access to the underlying dense linear eigensystem through a pointer to the private member data.

Definition at line 53 of file ODE_EVP.cpp.

                                                        {
    return p_SYSTEM;
  }

Referenced by main(), and CppNoddy::Example::Neutral_residual::Neutral_residual().

---

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

• include/ODE_EVP.h
• src/ODE_EVP.cpp