A one dimensional mesh utility object. More...

#include <OneD_Node_Mesh.h>

Public Member Functions
	OneD_Node_Mesh ()
	Default constructor. More...

	OneD_Node_Mesh (const DenseVector< _Xtype > &nodes, const std::size_t nvars)
	ctor for a given nodal distribution More...

template<typename _sourceType >
	OneD_Node_Mesh (const OneD_Node_Mesh< _sourceType > &source)
	implicit conversion ctor for D_complex from double data More...

	OneD_Node_Mesh (std::string filename, const std::size_t nnodes, const std::size_t nvars)
	ctor from an existing file More...

virtual	~OneD_Node_Mesh ()
	Destructor. More...

_Type &	operator() (const std::size_t i, const std::size_t var)
	Access a variable at a node. More...

const _Type &	operator() (const std::size_t i, const std::size_t var) const
	Access a variable at a node. More...

const _Xtype &	coord (const std::size_t &node) const
	Access a nodal position. More...

_Xtype &	coord (const std::size_t &node)
	Access a nodal position. More...

void	set_nodes_vars (const std::size_t node, const DenseVector< _Type > &u)
	Set the variables stored at A SPECIFIED node. More...

DenseVector< _Type >	get_nodes_vars (const std::size_t &node) const
	Get the variables stored at A SPECIFIED node. More...

DenseVector< _Type >	get_interpolated_vars (const _Xtype &pos) const
	Get the variable data at an interpolated position using a first order scheme. More...

std::size_t	get_nnodes () const

std::size_t	get_nvars () const

const DenseVector< _Xtype > &	nodes () const

DenseVector< double >	find_roots1 (const std::size_t &var, double value=0.0) const
	Find a list of approximate locations at which a specified variable attains a given value. More...

_Type	integral2 (std::size_t var=0) const
	Integrate over the domain. More...

_Xtype	squared_integral2 (std::size_t var=0) const
	Compute the integral of the absolute variable squared: \|variable\|^2. More...

_Type	integral4 (std::size_t var=0) const
	Integrate over the domain with a Simpson rule. More...

const DenseVector< _Type > &	vars_as_vector () const
	For each nodal point we push each variable into a vector in sequence. More...

void	set_vars_from_vector (const DenseVector< _Type > &vec)
	Set the variables of this mesh from a vector. More...

const std::vector< DenseVector< _Type > > &	get_vars () const

void	dump () const
	A simple method for dumping data to std::cout. More...

void	dump_gnu (std::string filename, int precision=10) const
	A simple method for dumping data to a file for gnuplot. More...

void	remesh1 (const DenseVector< _Xtype > &z)
	Interpolate this mesh data (linearly) into a new mesh with nodal points defined in the argument list. More...

void	scale (_Type x)
	Scale the whole contents of the mesh. More...

void	normalise (const std::size_t &var)
	Normalise all data in the mesh based on one variable. More...

double	max_abs (unsigned var)
	Find the maximum stored absolute value in the mesh for a given variable in a range of the domain. More...

void	read (std::string filename, const bool reset=false)
	Assign mesh contents using a filename. More...

DenseVector< double >	find_roots1 (const std::size_t &var, double value) const

void	remesh1 (const DenseVector< double > &newX)

void	remesh1 (const DenseVector< double > &newX)

void	remesh1 (const DenseVector< std::complex< double > > &z)

DenseVector< double >	get_interpolated_vars (const double &x_pos) const

DenseVector< std::complex< double > >	get_interpolated_vars (const double &x_pos) const

DenseVector< std::complex< double > >	get_interpolated_vars (const std::complex< double > &pos) const

DenseVector< double >	find_roots1 (const std::size_t &var, double value) const

void	read (std::string filename, bool reset)

void	read (std::string filename, bool reset)

void	read (std::string filename, bool reset)

void	dump_gnu (std::string filename, int precision) const

void	dump_gnu (std::string filename, int precision) const

void	dump_gnu (std::string filename, int precision) const

Protected Attributes
std::size_t	m_nv

DenseVector< _Xtype >	m_X

DenseVector< _Type >	m_vars

Detailed Description

template<typename _Type, typename _Xtype = double>
class CppNoddy::OneD_Node_Mesh< _Type, _Xtype >

A one dimensional mesh utility object.

Data can be placed into the mesh for interpolation to a new mesh or computation of integrals of the data. The default typing assumes that the mesh is along the real line. You can store (complex) data across a set of points in the complex plane using the second typename.

Definition at line 24 of file OneD_Node_Mesh.h.

Constructor & Destructor Documentation

◆ OneD_Node_Mesh() [1/4]

template<typename _Type , typename _Xtype = double>

CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh ( )

inline

Default constructor.

Definition at line 28 of file OneD_Node_Mesh.h.

                     {
      // default to zero variables
      m_nv = 0;
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_nv.

◆ OneD_Node_Mesh() [2/4]

template<typename _Type , typename _Xtype = double>

CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh	(	const DenseVector< _Xtype > &	nodes,
		const std::size_t	nvars
	)

inline

ctor for a given nodal distribution

Parameters

nodes	The positions of the nodal points
nvars	The number of variables to store in the mesh

Definition at line 36 of file OneD_Node_Mesh.h.

                                                                            :
      m_nv(nvars), m_X(nodes) {
#ifdef PARANOID
      for(unsigned i = 1; i < m_X.size(); ++i) {
        /*
          if ( m_X[i+1] < m_X[i] )
          {
          std::string problem;
          problem = "The OneD_Node_Mesh has been passed a vector of nodes that are\n";
          problem += "not in INCREASING order. This will screw up some of the methods\n";
          problem += "in the class. We should fix this .....\n";
          throw ExceptionRuntime( problem );
          }
        */
      }
#endif
      // set the contents to zero
      m_vars = DenseVector<_Type>(m_nv * m_X.size(), _Type(0.0));
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_nv, CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_vars, and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_X.

◆ OneD_Node_Mesh() [3/4]

template<typename _Type , typename _Xtype >

template<typename _sourceType >

CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh ( const OneD_Node_Mesh< _sourceType > & source )

inline

implicit conversion ctor for D_complex from double data

Definition at line 259 of file OneD_Node_Mesh.h.

                                                                                               {
    // there is implicit conversion of DenseVector so this will
    // allow copy of OneD_Node_Mesh<double> to OneD_Node_Mesh<D_complex>.
    m_nv = source.get_nvars();
    m_X = source.nodes();
    m_vars = source.vars_as_vector();
  }

◆ OneD_Node_Mesh() [4/4]

template<typename _Type , typename _Xtype = double>

CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh	(	std::string	filename,
		const std::size_t	nnodes,
		const std::size_t	nvars
	)

inline

ctor from an existing file

Parameters

filename	Filename of the data file
nnodes	Number of nodes
nvars	Number of variables stored at each node

Definition at line 64 of file OneD_Node_Mesh.h.

                                                                                       :
      m_nv(nvars) {
      m_X = DenseVector<_Xtype>(nnodes, _Xtype(0.0) ); //coordinates, currently empty
      m_vars = DenseVector<_Type>(nvars*nnodes, _Type(0.0) ); // nodal values
      read(filename, true); // true => reset the nodal coordinates using file
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_vars, CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_X, and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::read().

◆ ~OneD_Node_Mesh()

template<typename _Type , typename _Xtype = double>

virtual CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::~OneD_Node_Mesh ( )

inlinevirtual

Destructor.

Definition at line 72 of file OneD_Node_Mesh.h.

73 {}

Member Function Documentation

◆ coord() [1/2]

template<typename _Type , typename _Xtype >

_Xtype & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord ( const std::size_t & node )

inline

Access a nodal position.

Parameters

node	The nodal position to return

Returns: The spatial position of this node

Definition at line 283 of file OneD_Node_Mesh.h.

                                                                           {
    return m_X[ node ];
  }

◆ coord() [2/2]

template<typename _Type , typename _Xtype >

const _Xtype & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord ( const std::size_t & node ) const

inline

Access a nodal position.

Parameters

node	The nodal position to return

Returns: The spatial position of this node

Definition at line 278 of file OneD_Node_Mesh.h.

                                                                                       {
    return m_X[ node ];
  }

Referenced by CppNoddy::FT::dft(), CppNoddy::FT::dft_with_shift(), CppNoddy::HST::Orr_Sommerfeld::global_evp(), CppNoddy::FT::idft(), CppNoddy::FT::idft_with_ishift(), CppNoddy::FT::ishift(), main(), CppNoddy::Utility::max_abs_location(), CppNoddy::Utility::max_abs_location_range(), and CppNoddy::FT::shift().

◆ dump()

template<typename _Type , typename _Xtype >

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::dump

A simple method for dumping data to std::cout.

Definition at line 499 of file OneD_Node_Mesh.cpp.

                                                 {
    std::cout << "Number of nodes = " << m_X.size() << "\n";
    std::cout << "Nodal positions :\n";
    m_X.dump();
    std::cout << "\n";
    std::cout << "Number of vars = " << m_nv << "\n";
    std::cout << "Interleaved mesh data : \n";
    m_vars.dump();
    std::cout << "Mesh dump complete\n";
  }

Referenced by main().

◆ dump_gnu() [1/4]

void CppNoddy::OneD_Node_Mesh< double, double >::dump_gnu	(	std::string	filename,
		int	precision
	)		const

Definition at line 511 of file OneD_Node_Mesh.cpp.

                                                                                       {
    std::ofstream dump;
    dump.open(filename.c_str());
    dump.precision(precision);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    for(std::size_t i = 0; i < m_X.size(); ++i) {
      dump << m_X[ i ] << " ";
      for(std::size_t var = 0; var < m_nv; ++var) {
        dump << m_vars[ i * m_nv + var ] << " ";
      }
      dump << "\n";
    }
  }

◆ dump_gnu() [2/4]

void CppNoddy::OneD_Node_Mesh< std::complex< double >, double >::dump_gnu	(	std::string	filename,
		int	precision
	)		const

Definition at line 528 of file OneD_Node_Mesh.cpp.

                                                                                                     {
    std::ofstream dump;
    dump.open(filename.c_str());
    dump.precision(precision);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    for(std::size_t i = 0; i < m_X.size(); ++i) {
      dump << m_X[ i ] << " ";
      for(std::size_t var = 0; var < m_nv; ++var) {
        dump << real(m_vars[ i * m_nv + var ]) << " " << imag(m_vars[ i * m_nv + var ]) << " ";
      }
      dump << "\n";
    }
  }

◆ dump_gnu() [3/4]

void CppNoddy::OneD_Node_Mesh< std::complex< double >, std::complex< double > >::dump_gnu	(	std::string	filename,
		int	precision
	)		const

Definition at line 545 of file OneD_Node_Mesh.cpp.

                                                                                                                 {
    std::ofstream dump;
    dump.open(filename.c_str());
    dump.precision(precision);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    for(std::size_t i = 0; i < m_X.size(); ++i) {
      dump << real(m_X[ i ]) << " " << imag(m_X[ i ]) << " ";
      for(std::size_t var = 0; var < m_nv; ++var) {
        dump << real(m_vars[ i * m_nv + var ]) << " " << imag(m_vars[ i * m_nv + var ]) << " ";
      }
      dump << "\n";
    }
  }

◆ dump_gnu() [4/4]

template<typename _Type , typename _Xtype = double>

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::dump_gnu	(	std::string	filename,
		int	precision = `10`
	)		const

A simple method for dumping data to a file for gnuplot.

Parameters

filename	The filename to write the data to (will overwrite)
precision	Precision of the output strings

Referenced by main().

◆ find_roots1() [1/3]

DenseVector< double > CppNoddy::OneD_Node_Mesh< double, double >::find_roots1	(	const std::size_t &	var,
		double	value
	)		const

Definition at line 65 of file OneD_Node_Mesh.cpp.

                                                                                                          {
    DenseVector<double> roots;
    for(std::size_t node = 0; node < m_X.size() - 1; ++node) {
      std::size_t offset(node * m_nv + var);
      // find bracket nodes
      if((m_vars[ offset ] - value) * (m_vars[ offset + m_nv ] - value) < 0.0) {
        double deriv = (m_vars[ offset + m_nv ] - m_vars[ offset ]) / (m_X[ node + 1 ] - m_X[ node ]);
        double x = m_X[ node ] + (value - m_vars[ offset ]) / deriv;
        // add the left hand node to the roots vector
        roots.push_back(x);
      }
    }
    return roots;
  }

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

◆ find_roots1() [2/3]

DenseVector< double > CppNoddy::OneD_Node_Mesh< std::complex< double >, double >::find_roots1	(	const std::size_t &	var,
		double	value
	)		const

Definition at line 306 of file OneD_Node_Mesh.cpp.

                                                                                                                       {
    std::string problem;
    problem = " The OneD_Node_Mesh.find_roots1 method has been called with \n";
    problem += " a mesh containing complex data.\n";
    throw ExceptionRuntime(problem);
  }

◆ find_roots1() [3/3]

template<typename _Type , typename _Xtype = double>

DenseVector< double > CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::find_roots1	(	const std::size_t &	var,
		double	value = `0.0`
	)		const

Find a list of approximate locations at which a specified variable attains a given value.

First order only.

Parameters

var	The variable to be examined for zeros
value	The value to find

Referenced by main().

◆ get_interpolated_vars() [1/4]

template<typename _Type , typename _Xtype = double>

DenseVector< _Type > CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_interpolated_vars ( const _Xtype & pos ) const

Get the variable data at an interpolated position using a first order scheme.

Doesn't really make sense unless the data is along the real line.

Parameters

pos	The position to interpolate at.

Returns: A vector of interpolated variables.

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_interpolated_vars(), CppNoddy::TwoD_Node_Mesh< _Type >::get_interpolated_vars(), and main().

◆ get_interpolated_vars() [2/4]

DenseVector< double > CppNoddy::OneD_Node_Mesh< double, double >::get_interpolated_vars ( const double & x_pos ) const

Definition at line 209 of file OneD_Node_Mesh.cpp.

                                                                                                     {
    for(unsigned node = 0; node < m_X.size() - 1; ++node) {
      // find bracketing nodes - incl shameless hack for evaluations at the boundary
      //if ( ( m_X[ node ] < x_pos  || std::abs( m_X[ node ] - x_pos ) < 1.e-7 ) &&
      //( m_X[ node + 1 ] > x_pos || std::abs( m_X[ node + 1 ] - x_pos ) < 1.e-7 ) )
      if(((m_X[ node ] < x_pos) && (m_X[ node + 1 ] > x_pos))
          || (std::abs(m_X[ node ] - x_pos) < 1.e-7) || (std::abs(m_X[ node + 1 ] - x_pos) < 1.e-7)) {
        // distance from left node
        double delta_x(x_pos - m_X[ node ]);
        // empty data to return
        DenseVector<double> left;
        DenseVector<double> right;
        DenseVector<double> deriv;
        // interpolate data linearly
        left = get_nodes_vars(node);
        right = get_nodes_vars(node + 1);
        deriv = (right - left) / (m_X[ node + 1 ] - m_X[ node ]);
        // overwrite right
        right = left + deriv * delta_x;
        return right;
      }
    }
    std::cout << "You asked for a position of " << x_pos << " in a range " << m_X[ 0 ] << " to " << m_X[ m_X.size() - 1 ] << "\n";
    std::string problem;
    problem = "You have asked the OneD_Node_Mesh class to interpolate data at\n";
    problem += "a point that is outside the range covered by the mesh object.\n";
    throw ExceptionRuntime(problem);
  }

◆ get_interpolated_vars() [3/4]

DenseVector< std::complex< double > > CppNoddy::OneD_Node_Mesh< std::complex< double >, double >::get_interpolated_vars ( const double & x_pos ) const

Definition at line 240 of file OneD_Node_Mesh.cpp.

                                                                                                                              {
    for(unsigned node = 0; node < m_X.size() - 1; ++node) {
      // find bracketing nodes - incl shameless hack for evaluations at the boundary
      if((m_X[ node ] < x_pos  || std::abs(m_X[ node ] - x_pos) < 1.e-7) &&
          (m_X[ node + 1 ] > x_pos || std::abs(m_X[ node + 1 ] - x_pos) < 1.e-7)) {
        // distance from left node
        double delta_x(x_pos - m_X[ node ]);
        // empty data to return
        DenseVector<std::complex<double> > left;
        DenseVector<std::complex<double> > right;
        DenseVector<std::complex<double> > deriv;
        // interpolate data linearly
        left = get_nodes_vars(node);
        right = get_nodes_vars(node + 1);
        deriv = (right - left) / (m_X[ node + 1 ] - m_X[ node ]);
        // overwrite right
        right = left + deriv * delta_x;
        return right;
      }
    }
    std::cout << "You asked for a position of " << x_pos << " in a range " << m_X[ 0 ] << " to " << m_X[ m_X.size() - 1 ] << "\n";
    std::string problem;
    problem = "You have asked the OneD_Node_Mesh class to interpolate data at\n";
    problem += "a point that is outside the range covered by the mesh object.\n";
    throw ExceptionRuntime(problem);
  }

◆ get_interpolated_vars() [4/4]

DenseVector< std::complex< double > > CppNoddy::OneD_Node_Mesh< std::complex< double >, std::complex< double > >::get_interpolated_vars ( const std::complex< double > & pos ) const

Definition at line 269 of file OneD_Node_Mesh.cpp.

                                                                                                                                                     {
    double x_pos(pos.real());
#ifdef PARANOID
    std::cout << "WARNING: You are interpolating complex data on a complex mesh with 'get_interpolated_vars'.\n";
    std::cout << " This does a simple piecewise linear interpolating assuming a single valued path. \n";
#endif
    for(unsigned node = 0; node < m_X.size() - 1; ++node) {
      // find bracketing nodes - incl shameless hack for evaluations at the boundary
      if((m_X[ node ].real() < x_pos  || std::abs(m_X[ node ].real() - x_pos) < 1.e-7) &&
          (m_X[ node + 1 ].real() > x_pos || std::abs(m_X[ node + 1 ].real() - x_pos) < 1.e-7)) {
        // distance from left node -- real coordinate is given. We also need to
        // interpolate between the two complex nodes -- hence imaginary coordinate is implict from
        // bracketing (complex) nodes
        std::complex<double> delta_z = (m_X[ node + 1 ] - m_X[ node ]) * (x_pos - m_X[ node ].real()) / (m_X[ node + 1 ].real() - m_X[ node ].real());
        // empty data to return
        DenseVector<std::complex<double> > left;
        DenseVector<std::complex<double> > right;
        DenseVector<std::complex<double> > deriv;
        // interpolate data linearly
        left = get_nodes_vars(node);
        right = get_nodes_vars(node + 1);
        // derivative of the data
        deriv = (right - left) / (m_X[ node + 1 ] - m_X[ node ]);
        // overwrite right
        right = left + deriv * delta_z;
        return right;
      }
    }
    std::cout << "You asked for a position of " << x_pos << " in a range " << m_X[ 0 ] << " to " << m_X[ m_X.size() - 1 ] << "\n";
    std::string problem;
    problem = "You have asked the OneD_Node_Mesh class to interpolate data at\n";
    problem += "a point that is outside the range covered by the mesh object.\n";
    problem += "Even for complex nodes we assume the path is single valued.\n";
    throw ExceptionRuntime(problem);
  }

◆ get_nnodes()

template<typename _Type , typename _Xtype >

std::size_t CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nnodes

Returns: The number of nodal points in the mesh

Definition at line 50 of file OneD_Node_Mesh.cpp.

                                                            {
    return m_X.size();
  }

Referenced by CppNoddy::HST::Rayleigh< _Type >::eigenvector(), CppNoddy::HST::Orr_Sommerfeld::global_evp(), CppNoddy::FT::idft(), CppNoddy::FT::ishift(), main(), CppNoddy::Utility::max_abs_location(), CppNoddy::Utility::max_abs_location_range(), and CppNoddy::FT::shift().

◆ get_nodes_vars()

template<typename _Type , typename _Xtype >

DenseVector< _Type > CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nodes_vars ( const std::size_t & node ) const

Get the variables stored at A SPECIFIED node.

Parameters

node	The nodal index to be returned

Returns: The vector of VARIABLES stored at this nodal point

Definition at line 33 of file OneD_Node_Mesh.cpp.

                                                                                              {
#ifdef PARANOID
    if((node >= m_X.size()) || (node < 0)) {
      std::string problem;
      problem = " The OneD_Node_Mesh.get_nodes_vars method is trying to access \n";
      problem += " a nodal point outside of the range stored. \n";
      throw ExceptionRange(problem, m_X.size(), node);
    }
#endif
    DenseVector<_Type> nodes_vars;
    for(std::size_t var = 0; var < m_nv; ++var) {
      nodes_vars.push_back(m_vars[ node * m_nv + var ]);
    }
    return nodes_vars;
  }

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

Referenced by CppNoddy::FT::dft_with_shift(), CppNoddy::FT::idft(), and CppNoddy::FT::idft_with_ishift().

◆ get_nvars()

template<typename _Type , typename _Xtype >

std::size_t CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nvars

Returns: The number of variables that have data stored at each nodal point

Definition at line 55 of file OneD_Node_Mesh.cpp.

                                                           {
    return m_nv;
  }

Referenced by CppNoddy::FT::idft(), CppNoddy::FT::ishift(), and CppNoddy::FT::shift().

◆ get_vars()

template<typename _Type , typename _Xtype = double>

const std::vector< DenseVector< _Type > > & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_vars ( ) const

Returns: An STL vector of dense vectors of the variables in the mesh

◆ integral2()

template<typename _Type , typename _Xtype >

_Type CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::integral2 ( std::size_t var = 0 ) const

Integrate over the domain.

Typically useful for finite volume methods.

Parameters

var	The variable-index to be integrated over the mesh using a trapezium rule.

Returns: The integral value.

Definition at line 314 of file OneD_Node_Mesh.cpp.

                                                                    {
    _Type sum = 0.0;
    _Xtype dx = 0.0;
    // sum interior segments
    for(std::size_t node = 0; node < m_X.size() - 1; ++node) {
      dx = (m_X[ node + 1 ] - m_X[ node ]);
      sum += 0.5 * dx * (m_vars[ node * m_nv + var ] + m_vars[(node+1) * m_nv + var ]);
    }
    // return the value
    return sum;
  }

Referenced by main().

◆ integral4()

template<typename _Type , typename _Xtype >

_Type CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::integral4 ( std::size_t var = 0 ) const

Integrate over the domain with a Simpson rule.

Parameters

var	The variable-index to be integrated over the mesh using a trapezium rule.

Returns: The integral value.

Definition at line 341 of file OneD_Node_Mesh.cpp.

                                                                    {
    if((m_X.size()) % 2 == 0) {
      std::string problem;
      problem = " The OneD_Node_Mesh.Simpson_integral method is trying to run \n";
      problem += " on a mesh with an even number of points. \n";
      throw ExceptionRuntime(problem);
    }
 
    _Type f0, f1, f2;
    _Xtype x0, x1, x2;
 
    _Type sum = 0.0;
 
    // sum interior segments
    for(std::size_t node = 0; node < m_X.size() - 2; node += 2) {
      x0 = m_X[ node ];
      x1 = m_X[ node + 1 ];
      x2 = m_X[ node + 2 ];
      f0 = m_vars[ node * m_nv + var ];
      f1 = m_vars[(node+1) * m_nv + var ];
      f2 = m_vars[(node+2) * m_nv + var ];
      sum += (x2 - x0)
        * (
           f1 * pow(x0 - x2, 2) + f0 * (x1 - x2) * (2. * x0 - 3. * x1 + x2)
           - f2 * (x0 - x1) * (x0 - 3. * x1 + 2. * x2)
           )
        / (6. * (x0 - x1) * (x1 - x2));
      // sum += (x1-x0)*( f0 + 4*f1 + f2 ) / 3.0 for equal spacing
    }
    // return the value
    return sum;
  }

Referenced by main().

◆ max_abs()

template<typename _Type , typename _Xtype = double>

double CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::max_abs ( unsigned var )

inline

Find the maximum stored absolute value in the mesh for a given variable in a range of the domain.

Parameters

var	The variable index whose maximum is being asked for
left	Only examine the sub-range x>left
right	Only examine the sub-range x<right

Returns: The value of the maximum (abs value) Find the maximum stored absolute value in the mesh for a given variable – no interpolation is used

Parameters

var	The variable index whose maximum is being asked for

Returns: The value of the maximum (abs value)

Definition at line 228 of file OneD_Node_Mesh.h.

                                 {
      double max(0.0);
      // step through the nodes
      for(unsigned node = 0; node < m_X.size(); ++node) {
        if(std::abs(m_vars[ node * m_nv + var ]) > max) {
          max = std::abs(m_vars[ node * m_nv + var ]);
        }
      }
      return max;
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_nv, CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_vars, and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_X.

Referenced by CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::normalise().

◆ nodes()

template<typename _Type , typename _Xtype >

const DenseVector< _Xtype > & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::nodes

Returns: A vector of the nodal positions for this mesh

Definition at line 60 of file OneD_Node_Mesh.cpp.

                                                                        {
    return m_X;
  }

Referenced by CppNoddy::HST::Rayleigh< _Type >::eigenvector().

◆ normalise()

template<typename _Type , typename _Xtype = double>

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::normalise ( const std::size_t & var )

inline

Normalise all data in the mesh based on one variable.

Parameters

var	This var will have its peak (absolute) value as +/-unity following the normalisation. All other variables will also be rescaled by the same amount.

Definition at line 184 of file OneD_Node_Mesh.h.

                                         {
      double maxval(max_abs(var));
      m_vars.scale(1./maxval);
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_vars, and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::max_abs().

Referenced by main().

◆ operator()() [1/2]

template<typename _Type , typename _Xtype >

_Type & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::operator()	(	const std::size_t	i,
		const std::size_t	var
	)

inline

Access a variable at a node.

Parameters

i	The index of the node to be accessed
var	The variable to return the data for

Returns: The variable stored at the node

Definition at line 268 of file OneD_Node_Mesh.h.

                                                                                                {
    return m_vars[ i * m_nv + var ];
  }

◆ operator()() [2/2]

template<typename _Type , typename _Xtype >

const _Type & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::operator()	(	const std::size_t	i,
		const std::size_t	var
	)		const

inline

Access a variable at a node.

Parameters

i	The index of the node to be accessed
var	The variable to return the data for

Returns: The variable stored at the node

Definition at line 273 of file OneD_Node_Mesh.h.

                                                                                                            {
    return m_vars[ i * m_nv + var ];
  }

◆ read() [1/4]

void CppNoddy::OneD_Node_Mesh< double, double >::read	(	std::string	filename,
		bool	reset
	)

Definition at line 377 of file OneD_Node_Mesh.cpp.

                                                                            {
    std::ifstream dump;
    std::cout << "[INFO] Reading OneD_Node_Mesh<double,double> data from " + filename + "\n";
    dump.open(filename.c_str());
    if (dump.good() != true) {
      std::string problem;
      problem = " The OneD_Node_Mesh.read method is trying to read a \n";
      problem += " file (" + filename + ") that doesn't exist.\n";
      throw ExceptionRuntime(problem);
    }
    dump.precision(15);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    std::size_t N = get_nnodes();
    for (std::size_t i = 0; i < N; ++i) {
        double x;
        dump >> x;
        for (std::size_t var = 0; var < m_nv; ++var) {
          double value;
          dump >> value;
          m_vars[ i * m_nv + var ] = value;
        }
        if (reset != true) {
          // if not reseting the mesh we should check the node positions
          if (std::fabs(x - m_X[ i ]) > 1.e-6) {
            std::cout << " Read x = " << x << " Expected x = " << m_X[ i ] << "\n";
            std::cout << " Absolute differences are " << fabs(x - m_X[i]) <<  "\n";
            std::string problem;
            problem = " The TwoD_Node_Mesh.read method is trying to read a \n";
            problem += " file whose nodal points are in a different position. \n";
            throw ExceptionRuntime(problem);
          }
        } else {
          m_X[ i ] = x;
        }
    }
  }

◆ read() [2/4]

void CppNoddy::OneD_Node_Mesh< D_complex, double >::read	(	std::string	filename,
		bool	reset
	)

Definition at line 417 of file OneD_Node_Mesh.cpp.

                                                                               {
    std::ifstream dump;
    std::cout << "[INFO] Reading OneD_Node_Mesh<D_complex,double> data from " + filename + "\n";
    dump.open(filename.c_str());
    if (dump.good() != true) {
      std::string problem;
      problem = " The OneD_Node_Mesh.read method is trying to read a \n";
      problem += " file (" + filename + ") that doesn't exist.\n";
      throw ExceptionRuntime(problem);
    }
    dump.precision(15);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    std::size_t N = get_nnodes();
    for (std::size_t i = 0; i < N; ++i) {
        double x;
        dump >> x;
        for (std::size_t var = 0; var < m_nv; ++var) {
          double rValue, iValue;
          dump >> rValue; dump >> iValue;
          m_vars[ i * m_nv + var ] = D_complex(rValue,iValue);
        }
        if (reset != true) {
          // if not reseting the mesh we should check the node positions
          if (std::fabs(x - m_X[ i ]) > 1.e-6) {
            std::cout << " Read x = " << x << " Expected x = " << m_X[ i ] << "\n";
            std::cout << " Absolute differences are " << fabs(x - m_X[i]) <<  "\n";
            std::string problem;
            problem = " The TwoD_Node_Mesh.read method is trying to read a \n";
            problem += " file whose nodal points are in a different position. \n";
            throw ExceptionRuntime(problem);
          }
        } else {
          m_X[ i ] = x;
        }
    }
  }

◆ read() [3/4]

void CppNoddy::OneD_Node_Mesh< D_complex, D_complex >::read	(	std::string	filename,
		bool	reset
	)

Definition at line 457 of file OneD_Node_Mesh.cpp.

                                                                                  {
    std::ifstream dump;
    std::cout << "[INFO] Reading OneD_Node_Mesh<D_complex, D_complex> data from " + filename + "\n";
    dump.open(filename.c_str());
    if (dump.good() != true) {
      std::string problem;
      problem = " The OneD_Node_Mesh.read method is trying to read a \n";
      problem += " file (" + filename + ") that doesn't exist.\n";
      throw ExceptionRuntime(problem);
    }
    dump.precision(15);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    std::size_t N = get_nnodes();
    for (std::size_t i = 0; i < N; ++i) {
      double rX, iX;
      dump >> rX; dump >> iX;
      D_complex X(rX,iX);
      for (std::size_t var = 0; var < m_nv; ++var) {
        double rValue, iValue;
        dump >> rValue; dump >> iValue;
        m_vars[ i * m_nv + var ] = D_complex(rValue,iValue);
      }
      if (reset != true) {
        // if not reseting the mesh we should check the node positions
        if (std::fabs( X - m_X[ i ]) > 1.e-6) {
          std::cout << " Read x = " << X << " Expected x = " << m_X[ i ] << "\n";
          std::cout << " Absolute differences are " << fabs( X - m_X[i]) <<  "\n";
          std::string problem;
          problem = " The TwoD_Node_Mesh.read method is trying to read a \n";
          problem += " file whose nodal points are in a different position. \n";
          throw ExceptionRuntime(problem);
        }
      } else {
        m_X[ i ] = X;
      }
    }
  }

◆ read() [4/4]

template<typename _Type , typename _Xtype = double>

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::read	(	std::string	filename,
		const bool	reset = `false`
	)

Assign mesh contents using a filename.

Parameters

filename	Filename that contains the data
reset	A boolean, if true then coordinate data is overwritten using the file data. Default is false.

Referenced by CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh().

◆ remesh1() [1/4]

template<typename _Type , typename _Xtype = double>

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::remesh1 ( const DenseVector< _Xtype > & z )

Interpolate this mesh data (linearly) into a new mesh with nodal points defined in the argument list.

Parameters

z	The nodal coordinates to be used in the new mesh.

Referenced by main(), and CppNoddy::HST::Rayleigh< _Type >::remesh1().

◆ remesh1() [2/4]

void CppNoddy::OneD_Node_Mesh< double, double >::remesh1 ( const DenseVector< double > & newX )

Definition at line 99 of file OneD_Node_Mesh.cpp.

                                                                              {
#ifdef PARANOID
    if(std::abs(m_X[ 0 ] - newX[ 0 ]) > 1.e-10 ||
        std::abs(m_X[ m_X.size() - 1 ] - newX[ newX.size() - 1 ]) > 1.e-10) {
      std::string problem;
      problem = " The OneD_Node_Mesh.remesh method has been called with \n";
      problem += " a passed coordinate vector that has different start and/or \n";
      problem += " end points from the instantiated object. \n";
      throw ExceptionRuntime(problem);
    }
 
    for(std::size_t i = 0; i < newX.size() - 1; ++i) {
      if(newX[ i ] >= newX[ i + 1 ]) {
        std::string problem;
        problem = " The OneD_Node_Mesh.remesh method has been passed \n";
        problem += " a non-monotonic coordinate vector. \n";
        throw ExceptionRuntime(problem);
      }
    }
#endif
    // copy current state of this mesh
    DenseVector<double> copy_of_vars(m_vars);
    // resize the local storage
    m_vars.resize(newX.size() * m_nv);
 
    // first nodal values are assumed to be untouched
    // loop thru destination mesh node at a time
    for(std::size_t node = 1; node < newX.size() - 1; ++node) {
      // loop through the source mesh and find the bracket-nodes
      for(std::size_t i = 0; i < m_X.size(); ++i) {
        if((m_X[ i ] <= newX[ node ]) && (newX[ node ] < m_X[ i + 1 ])) {
          // linearly interpolate each variable in the mesh
          for(std::size_t var = 0; var < m_nv; ++var) {
            double dX = newX[ node ] - m_X[ i ];
            double dvarsdX = (copy_of_vars[(i+1)*m_nv + var ] - copy_of_vars[ i*m_nv + var ]) / (m_X[ i + 1 ] - m_X[ i ]);
            m_vars[ node * m_nv + var ] = copy_of_vars[ i * m_nv + var ] + dX * dvarsdX;
          }
        }
      }
    }
 
    // add the last nodal values to the resized vector
    for(std::size_t var = 0; var < m_nv; ++var) {
      m_vars[(newX.size() - 1) * m_nv + var ] = copy_of_vars[(m_X.size() - 1) * m_nv + var ];
    }
    // replace the old nodes with the new ones
    m_X = newX;
  }

◆ remesh1() [3/4]

void CppNoddy::OneD_Node_Mesh< std::complex< double >, double >::remesh1 ( const DenseVector< double > & newX )

Definition at line 149 of file OneD_Node_Mesh.cpp.

                                                                                          {
#ifdef PARANOID
    if(std::abs(m_X[ 0 ] - newX[ 0 ]) > 1.e-10 ||
        std::abs(m_X[ m_X.size() - 1 ] - newX[ newX.size() - 1 ]) > 1.e-10) {
      std::string problem;
      problem = " The OneD_Node_Mesh.remesh method has been called with \n";
      problem += " a passed coordinate vector that has different start and/or \n";
      problem += " end points from the instantiated object. \n";
      throw ExceptionRuntime(problem);
    }
 
    for(std::size_t i = 0; i < newX.size() - 1; ++i) {
      if(newX[ i ] >= newX[ i + 1 ]) {
        std::string problem;
        problem = " The OneD_Node_Mesh.remesh method has been passed \n";
        problem += " a non-monotonic coordinate vector. \n";
        throw ExceptionRuntime(problem);
      }
    }
#endif
    // copy current state of this mesh
    DenseVector<std::complex<double> > copy_of_vars(m_vars);
    // resize the local storage
    m_vars.resize(newX.size() * m_nv);
 
    // first nodal values are assumed to be untouched
    // loop thru destination mesh node at a time
    for(std::size_t node = 1; node < newX.size() - 1; ++node) {
      // loop through the source mesh and find the bracket-nodes
      for(std::size_t i = 0; i < m_X.size(); ++i) {
        if((m_X[ i ] <= newX[ node ]) && (newX[ node ] < m_X[ i + 1 ])) {
          // linearly interpolate each variable in the mesh
          for(std::size_t var = 0; var < m_nv; ++var) {
            double dX = newX[ node ] - m_X[ i ];
            // if the paranoid checks above are satisfied, then the m_X[ i + 1 ] should still be in bounds
            std::complex<double> dvarsdX = (copy_of_vars[(i+1)*m_nv + var ] - copy_of_vars[ i*m_nv + var ]) / (m_X[ i + 1 ] - m_X[ i ]);
            m_vars[ node * m_nv + var ] = copy_of_vars[ i * m_nv + var ] + dX * dvarsdX;
          }
        }
      }
    }
 
    // add the last nodal values to the resized vector
    for(std::size_t var = 0; var < m_nv; ++var) {
      m_vars[(newX.size() - 1) * m_nv + var ] = copy_of_vars[(m_X.size() - 1) * m_nv + var ];
    }
    // replace the old nodes with the new ones
    m_X = newX;
 
  }

◆ remesh1() [4/4]

void CppNoddy::OneD_Node_Mesh< std::complex< double >, std::complex< double > >::remesh1 ( const DenseVector< std::complex< double > > & z )

Definition at line 201 of file OneD_Node_Mesh.cpp.

                                                                                                                 {
    std::string problem;
    problem = " The OneD_Node_Mesh.remesh method has been called with \n";
    problem += " a complex data set on a complex mesh.\n";
    throw ExceptionRuntime(problem);
  }

◆ scale()

template<typename _Type , typename _Xtype = double>

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::scale ( _Type x )

inline

Scale the whole contents of the mesh.

Parameters

x	The value to multiply the contents of the mesh by

Definition at line 176 of file OneD_Node_Mesh.h.

                        {
      m_vars.scale(x);
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_vars.

◆ set_nodes_vars()

template<typename _Type , typename _Xtype >

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::set_nodes_vars	(	const std::size_t	node,
		const DenseVector< _Type > &	u
	)

Set the variables stored at A SPECIFIED node.

Parameters

node	The nodal index to be set
u	The vector of VARIABLES to be written to this nodal point

Definition at line 17 of file OneD_Node_Mesh.cpp.

                                                                                                      {
#ifdef PARANOID
    if(U.size() != m_nv) {
      std::string problem;
      problem = " The OneD_Node_Mesh.set_node method is trying to add \n";
      problem += " an DenseVector of variables of a different size to that \n";
      problem += " stored at other nodal points. \n";
      throw ExceptionGeom(problem, m_nv, U.size());
    }
#endif
    for(std::size_t var = 0; var < U.size(); ++var) {
      m_vars[ node * m_nv + var ] = U[ var ];
    }
  }

References U.

Referenced by CppNoddy::ODE_EVP< _Type >::add_tagged_to_mesh(), CppNoddy::FT::dft(), CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_interpolated_vars(), CppNoddy::OneD_TVDLF_Mesh::get_slope(), CppNoddy::OneD_TVDLF_Mesh::get_soln(), CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_xsection_at_xnode(), CppNoddy::TwoD_Node_Mesh< _Type >::get_xsection_at_xnode(), CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_xsection_at_ynode(), and CppNoddy::TwoD_Node_Mesh< _Type >::get_xsection_at_ynode().

◆ set_vars_from_vector()

template<typename _Type , typename _Xtype >

void CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::set_vars_from_vector ( const DenseVector< _Type > & vec )

Set the variables of this mesh from a vector.

Parameters

vec	The vector to be used.

Definition at line 86 of file OneD_Node_Mesh.cpp.

                                                                                        {
#ifdef PARANOID
    if(vec.size() != m_nv * m_X.size()) {
      std::string problem;
      problem = "The set_vars_from_vector method has been passed a vector\n";
      problem += "of a length that is of an incompatible size for this mesh object\n";
      throw ExceptionRuntime(problem);
    }
#endif
    m_vars = vec;
  }

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

Referenced by main().

◆ squared_integral2()

template<typename _Type , typename _Xtype >

_Xtype CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::squared_integral2 ( std::size_t var = 0 ) const

Compute the integral of the absolute variable squared: |variable|^2.

Parameters

var	The variable-index to be integrated

Returns: The integral of the square of the absolute value.

Definition at line 327 of file OneD_Node_Mesh.cpp.

                                                                             {
    _Xtype sum = 0.0;
    double dx = 0.0;
    // sum interior segments
    for(std::size_t node = 0; node < m_X.size() - 1; ++node) {
      dx = std::abs(m_X[ node + 1 ] - m_X[ node ]);
      sum += 0.5 * dx * (std::pow(std::abs(m_vars[ node * m_nv + var ]), 2)
                         + std::pow(std::abs(m_vars[(node + 1) * m_nv + var ]), 2));
    }
    // return the value
    return std::sqrt(sum);
  }

◆ vars_as_vector()

template<typename _Type , typename _Xtype >

const DenseVector< _Type > & CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::vars_as_vector

For each nodal point we push each variable into a vector in sequence.

So the returned vector has the data v_00,,...,v_0n,v_10,...,v1n,....v_mn, where the first index denotes the nodal point 0-m and the second the variable 0-n.

Returns: A vector of the variables stored in the mesh

Definition at line 81 of file OneD_Node_Mesh.cpp.

                                                                                {
    return m_vars;
  }

Member Data Documentation

◆ m_nv

template<typename _Type , typename _Xtype = double>

std::size_t CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_nv

protected

Definition at line 247 of file OneD_Node_Mesh.h.

Referenced by CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::max_abs(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh().

◆ m_vars

template<typename _Type , typename _Xtype = double>

DenseVector<_Type> CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_vars

protected

Definition at line 251 of file OneD_Node_Mesh.h.

Referenced by CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::max_abs(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::normalise(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::scale().

◆ m_X

template<typename _Type , typename _Xtype = double>

DenseVector<_Xtype> CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::m_X

protected

Definition at line 249 of file OneD_Node_Mesh.h.

Referenced by CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::max_abs(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::OneD_Node_Mesh().

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

include/OneD_Node_Mesh.h
src/OneD_Node_Mesh.cpp

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ OneD_Node_Mesh() [1/4]

◆ OneD_Node_Mesh() [2/4]

◆ OneD_Node_Mesh() [3/4]

◆ OneD_Node_Mesh() [4/4]

◆ ~OneD_Node_Mesh()

Member Function Documentation

◆ coord() [1/2]

◆ coord() [2/2]

◆ dump()

◆ dump_gnu() [1/4]

◆ dump_gnu() [2/4]

◆ dump_gnu() [3/4]

◆ dump_gnu() [4/4]

◆ find_roots1() [1/3]

◆ find_roots1() [2/3]

◆ find_roots1() [3/3]

◆ get_interpolated_vars() [1/4]

◆ get_interpolated_vars() [2/4]

◆ get_interpolated_vars() [3/4]

◆ get_interpolated_vars() [4/4]

◆ get_nnodes()

◆ get_nodes_vars()

◆ get_nvars()

◆ get_vars()

◆ integral2()

◆ integral4()

◆ max_abs()

◆ nodes()

◆ normalise()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ read() [1/4]

◆ read() [2/4]

◆ read() [3/4]

◆ read() [4/4]

◆ remesh1() [1/4]

◆ remesh1() [2/4]

◆ remesh1() [3/4]

◆ remesh1() [4/4]

◆ scale()

◆ set_nodes_vars()

◆ set_vars_from_vector()

◆ squared_integral2()

◆ vars_as_vector()

Member Data Documentation

◆ m_nv

◆ m_vars

◆ m_X