A two dimensional (mapped) mesh utility object. More...

#include <TwoD_Mapped_Node_Mesh.h>

Inheritance diagram for CppNoddy::TwoD_Mapped_Node_Mesh< _Type >:

Public Member Functions
virtual double	FnComp_X (const double &zeta) const
	Mapping function that provides a computational X coordinate from a physical coordinate. More...

virtual double	FnComp_Xd (const double &zeta) const
	Mapping function that provides the first derivative of the computational m_X coordinate as a function of the physical coordinate. More...

virtual double	FnComp_Xdd (const double &zeta) const
	Mapping function that provides the second derivative of the computational X coordinate as a function of the physical coordinate. More...

virtual double	FnComp_Y (const double &eta) const
	Mapping function that provides the computational Y coordinate as a function of the physical coordinate. More...

virtual double	FnComp_Yd (const double &eta) const
	Mapping function that provides the first derivative of the computational Y coordinate as a function of the physical coordinate. More...

virtual double	FnComp_Ydd (const double &eta) const
	Mapping function that provides the second derivative of the computational Y coordinate as a function of the physical coordinate. More...

	TwoD_Mapped_Node_Mesh ()

	TwoD_Mapped_Node_Mesh (const double left, const double right, const double bottom, const double top, const std::size_t nx, const std::size_t ny, const std::size_t nvars)
	ctor of a blank mesh More...

	TwoD_Mapped_Node_Mesh (std::string filename, const std::size_t nx, const std::size_t ny, const std::size_t nv)

void	init_mapping ()
	Sometimes a useful mapping is painful to invert analytically. More...

std::pair< double, double >	get_comp_step_sizes () const

virtual	~TwoD_Mapped_Node_Mesh ()
	dtor More...

DenseVector< _Type >	operator() (const std::size_t nodex, const std::size_t nodey)
	Access operator for a nodal point that returns a vector. More...

_Type &	operator() (const std::size_t nodex, const std::size_t nodey, const std::size_t var)
	Access operator for a nodal point/variable in the mesh. More...

const _Type &	operator() (const std::size_t nodex, const std::size_t nodey, const std::size_t var) const
	Const access operator for a nodal point/variable in the mesh. More...

std::pair< double, double >	coord (const std::size_t nodex, const std::size_t nodey) const
	Access the physical nodal position - as a pair. More...

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

DenseVector< _Type >	get_nodes_vars (const std::size_t nodex, const std::size_t nodey) const
	Get the variables stored at A SPECIFIED node – equivalent to mesh(nodex,nodey). More...

std::pair< std::size_t, std::size_t >	get_nnodes () const
	Get the number of nodes in the two directions of the 2D mesh. More...

std::size_t	get_nvars () const
	Get the number of variables that are stored at each node. More...

DenseVector< double > &	xnodes ()
	Access the vector of x-nodal positions. More...

DenseVector< double > &	ynodes ()
	Access the vector of y-nodal positions. More...

OneD_Node_Mesh< _Type >	get_xsection_at_xnode (const std::size_t nodex) const
	Get a cross section of the 2D mesh at a specified (constant) x node. More...

OneD_Node_Mesh< _Type >	get_xsection_at_ynode (const std::size_t nodey) const
	Get a cross section of the 2D mesh at a specified (constant) y node. More...

void	read (std::string filename, const bool reset=false)
	A simple method for reading data from a file. More...

void	dump_gnu (std::string filename) const
	A simple method for dumping data to a file for gnuplot surface plotting. More...

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

void	scale (const _Type &value)
	Rescale all values stored in the mapped mesh by a scalar. More...

double	max (unsigned var)
	Find the maximum stored absolute value in the mesh for a given variable – no interpolation is used. More...

DenseVector< _Type >	get_interpolated_vars (const double &x, const double &y)
	Get a bilinearly interpolated value at a specified point. More...

void	normalise (const std::size_t &var)

void	normalise (const std::size_t &var)

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

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

void	dump_gnu (std::string filename) const

void	dump_gnu (std::string filename) const

Protected Attributes
double	m_left

double	m_right

double	m_bottom

double	m_top

std::size_t	m_nx

std::size_t	m_ny

std::size_t	m_nv

DenseVector< double >	m_compX

DenseVector< double >	m_compY

DenseVector< double >	m_X

DenseVector< double >	m_Y

DenseVector< _Type >	m_vars

Detailed Description

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

A two dimensional (mapped) mesh utility object.

Definition at line 21 of file TwoD_Mapped_Node_Mesh.h.

Constructor & Destructor Documentation

◆ TwoD_Mapped_Node_Mesh() [1/3]

template<typename _Type >

CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::TwoD_Mapped_Node_Mesh ( )

inline

Definition at line 90 of file TwoD_Mapped_Node_Mesh.h.

91 {}

◆ TwoD_Mapped_Node_Mesh() [2/3]

template<typename _Type >

CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::TwoD_Mapped_Node_Mesh	(	const double	left,
		const double	right,
		const double	bottom,
		const double	top,
		const std::size_t	nx,
		const std::size_t	ny,
		const std::size_t	nvars
	)

inline

ctor of a blank mesh

Definition at line 94 of file TwoD_Mapped_Node_Mesh.h.

                                                                                                                                                                       : m_left(left), m_right(right), m_bottom(bottom), m_top(top), m_nx(nx), m_ny(ny), m_nv(nvars) {
#ifdef DEBUG
      std::cout << "[DEBUG] making a blank TwoD_Mapped_Node_Mesh\n";
      std::cout << "[DEBUG] a " << nx << " by " << ny << " mesh with " << nvars << " variables.\n";
#endif      
      // initialise the storage, but fill these below in init_mapping()
      m_X = DenseVector<double> (m_nx,0.0);
      m_Y = DenseVector<double> (m_ny,0.0);
      m_compX = DenseVector<double> (m_nx,0.0);
      m_compY = DenseVector<double> (m_ny,0.0);
      // we'll store the data as ( x, y, v ) ->  x * ny * nv + y * nv + v
      m_vars = DenseVector<_Type>(m_nx * m_ny * m_nv, 0.0);
      // user needs to call init_mapping() to set up m_compX, m_compY after this
#ifdef DEBUG
      std::cout << "[DEBUG] leaving the TwoD_Mapped_Node_Mesh ctor.\n";
#endif
    }

References CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_compX, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_compY, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_nv, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_nx, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_ny, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_vars, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_X, and CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_Y.

◆ TwoD_Mapped_Node_Mesh() [3/3]

template<typename _Type >

CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::TwoD_Mapped_Node_Mesh	(	std::string	filename,
		const std::size_t	nx,
		const std::size_t	ny,
		const std::size_t	nv
	)

inline

Definition at line 114 of file TwoD_Mapped_Node_Mesh.h.

                                                                                                           :
      m_nx(nx), m_ny(ny), m_nv(nv) {
      // need storage for the coordinates
      m_X = DenseVector<double>(m_nx, 0.0);
      m_Y = DenseVector<double>(m_ny, 0.0);
      m_compX = DenseVector<double> (m_nx,0.0);
      m_compY = DenseVector<double> (m_ny,0.0);
      // we'll store the data as ( x, y, v ) ->  x * ny * nv + y * nv + v
      m_vars = DenseVector<_Type>(m_nx * m_ny * m_nv, 0.0);
      // now read the mesh from the given filename -- this also updates the m_X data
      read(filename, true);
      // set up the private member data on the box size.
      m_left = m_X[0];
      m_right = m_X[m_nx-1];
      m_bottom = m_Y[0];
      m_top = m_Y[m_ny-1];
      // user needs to call init_mapping() to set up m_compX, m_compY after this
    }

◆ ~TwoD_Mapped_Node_Mesh()

template<typename _Type >

virtual CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::~TwoD_Mapped_Node_Mesh ( )

inlinevirtual

dtor

Definition at line 143 of file TwoD_Mapped_Node_Mesh.h.

144 {}

Member Function Documentation

◆ coord()

template<typename _Type >

std::pair< double, double > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::coord	(	const std::size_t	nodex,
		const std::size_t	nodey
	)		const

inline

Access the physical nodal position - as a pair.

Parameters

nodex	The x nodal position to return
nodey	The y nodal position to return

Returns: The spatial position of this node as a pair

Definition at line 371 of file TwoD_Mapped_Node_Mesh.h.

                                                                                                                       {
#ifdef PARANOID
    if(nodex > m_nx - 1 || nodey > m_ny - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.coord method is trying to \n";
      problem += " access a nodal point that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nx, nodex, m_ny, nodey);
    }
#endif
    std::pair< double, double > pos;
    pos.first = m_X[ nodex ];
    pos.second = m_Y[ nodey ];
    return pos;
  }

Referenced by main().

◆ dump_gnu() [1/3]

template<typename _Type >

void CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::dump_gnu ( std::string filename ) const

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

Parameters

filename The filename to write the data to (will overwrite)

Referenced by main().

◆ dump_gnu() [2/3]

void CppNoddy::TwoD_Mapped_Node_Mesh< double >::dump_gnu ( std::string filename ) const

Definition at line 298 of file TwoD_Mapped_Node_Mesh.cpp.

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

◆ dump_gnu() [3/3]

void CppNoddy::TwoD_Mapped_Node_Mesh< D_complex >::dump_gnu ( std::string filename ) const

Definition at line 320 of file TwoD_Mapped_Node_Mesh.cpp.

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

◆ FnComp_X()

template<typename _Type >

virtual double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_X ( const double & zeta ) const

inlinevirtual

Mapping function that provides a computational X coordinate from a physical coordinate.

Parameters

zeta	The physical coordinate

Returns: The corresponding computational coordinate

Reimplemented in Example::My_Mesh< _Type >, and Example::My_Mesh< _Type >.

Definition at line 28 of file TwoD_Mapped_Node_Mesh.h.

                                                      {
      std::string problem;
      problem = "The TwoD_Mapped_Node_Mesh::FnComp_X method has not been implemented.\n";
      problem += "You have to implement this method to define the mesh.\n";
      throw ExceptionRuntime(problem);
    }

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_interpolated_vars().

◆ FnComp_Xd()

template<typename _Type >

virtual double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_Xd ( const double & zeta ) const

inlinevirtual

Mapping function that provides the first derivative of the computational m_X coordinate as a function of the physical coordinate.

Parameters

zeta	The physical coordinate

Returns: The corresponding derivative of the computational coordinate

Reimplemented in Example::My_Mesh< _Type >, and Example::My_Mesh< _Type >.

Definition at line 39 of file TwoD_Mapped_Node_Mesh.h.

                                                       {
      std::string problem;
      problem = "The TwoD_Mapped_Node_Mesh::FnComp_Xd method has not been implemented.\n";
      problem += "You have to implement this method to define the mesh.\n";
      throw ExceptionRuntime(problem);
    }

◆ FnComp_Xdd()

template<typename _Type >

virtual double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_Xdd ( const double & zeta ) const

inlinevirtual

Mapping function that provides the second derivative of the computational X coordinate as a function of the physical coordinate.

Parameters

zeta	The physical coordinate

Returns: The corresponding derivative of the computational coordinate

Reimplemented in Example::My_Mesh< _Type >, and Example::My_Mesh< _Type >.

Definition at line 50 of file TwoD_Mapped_Node_Mesh.h.

                                                        {
      std::string problem;
      problem = "The TwoD_Mapped_Node_Mesh::FnComp_Xdd method has not been implemented.\n";
      problem += "You have to implement this method to define the mesh.\n";
      throw ExceptionRuntime(problem);
    }

◆ FnComp_Y()

template<typename _Type >

virtual double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_Y ( const double & eta ) const

inlinevirtual

Mapping function that provides the computational Y coordinate as a function of the physical coordinate.

Parameters

eta	The physical coordinate

Returns: The corresponding derivative of the computational coordinate

Reimplemented in Example::My_Mesh< _Type >, and Example::My_Mesh< _Type >.

Definition at line 61 of file TwoD_Mapped_Node_Mesh.h.

                                                     {
      std::string problem;
      problem = "The TwoD_Mapped_Node_Mesh::FnComp_Y method has not been implemented.\n";
      problem += "You have to implement this method to define the mesh.\n";
      throw ExceptionRuntime(problem);
    }

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_interpolated_vars().

◆ FnComp_Yd()

template<typename _Type >

virtual double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_Yd ( const double & eta ) const

inlinevirtual

Mapping function that provides the first derivative of the computational Y coordinate as a function of the physical coordinate.

Parameters

eta	The physical coordinate

Returns: The corresponding derivative of the computational coordinate

Reimplemented in Example::My_Mesh< _Type >, and Example::My_Mesh< _Type >.

Definition at line 72 of file TwoD_Mapped_Node_Mesh.h.

                                                      {
      std::string problem;
      problem = "The TwoD_Mapped_Node_Mesh::FnComp_Yd method has not been implemented.\n";
      problem += "You have to implement this method to define the mesh.\n";
      throw ExceptionRuntime(problem);
    }

◆ FnComp_Ydd()

template<typename _Type >

virtual double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_Ydd ( const double & eta ) const

inlinevirtual

Mapping function that provides the second derivative of the computational Y coordinate as a function of the physical coordinate.

Parameters

eta	The physical coordinate

Returns: The corresponding derivative of the computational coordinate

Reimplemented in Example::My_Mesh< _Type >, and Example::My_Mesh< _Type >.

Definition at line 83 of file TwoD_Mapped_Node_Mesh.h.

                                                       {
      std::string problem;
      problem = "The TwoD_Mapped_Node_Mesh::FnComp_Ydd method has not been implemented.\n";
      problem += "You have to implement this method to define the mesh.\n";
      throw ExceptionRuntime(problem);
    }

◆ get_comp_step_sizes()

template<typename _Type >

std::pair< double, double > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_comp_step_sizes

Definition at line 155 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                                   {
    std::pair<double,double> steps;
    steps.first = m_compX[1]-m_compX[0];
    steps.second = m_compY[1]-m_compY[0];
    return steps;
  }

Referenced by main().

◆ get_interpolated_vars()

template<typename _Type >

DenseVector< _Type > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_interpolated_vars	(	const double &	x,
		const double &	y
	)

inline

Get a bilinearly interpolated value at a specified point.

Parameters

x	Physical (unmapped) x-coordinate in the 2D mesh
y	Physical (unmapped) y-coordinate in the 2D mesh

Returns: A vector of bilinearly interpolated values

Definition at line 251 of file TwoD_Mapped_Node_Mesh.h.

    {
      double compX = FnComp_X(x);
      double compY = FnComp_Y(y);
      const double tol(1.e-8);
      // check start and end
      if ((compX < m_compX[0] - tol) || (compX > m_compX[m_nx-1] + tol)) {
        std::string problem;
        problem = " The TwoD_Node_Mesh.get_interpolated_vars method has been called with \n";
        problem += " an x coordinate that lies outside the mesh. \n";
        throw ExceptionRuntime(problem);
      }
      // check start and end
      if ((compY < m_compY[0] - tol) || (compY > m_compY[m_ny-1] + tol)) {
        std::string problem;
        problem = " The TwoD_Node_Mesh.get_interpolated_vars method has been called with \n";
        problem += " a y coordinate that lies outside the mesh. \n";
        throw ExceptionRuntime(problem);
      }
      int bottom_j(-1);
      for (unsigned j = 0; j < m_ny-1; ++j) {
        if ((compY >= m_compY[j] - tol) && (compY <= m_compY[j+1] + tol)) {
          bottom_j = j;
        }
      }
      if (bottom_j == -1) {
        std::string problem;
        problem = " The TwoD_Node_Mesh.get_interpolated_vars method is broken.\n";
        throw ExceptionRuntime(problem);
      }
      //
      OneD_Node_Mesh<_Type> bottom_row( m_compX, m_nv );
      OneD_Node_Mesh<_Type> top_row( m_compX, m_nv );
      for (std::size_t i = 0; i < m_nx; ++i ) {
        bottom_row.set_nodes_vars(i, this -> get_nodes_vars(i, bottom_j));
        top_row.set_nodes_vars(i, this -> get_nodes_vars(i, bottom_j+1));
      }
      const double compY1 = m_compY[ bottom_j ];
      const double compY2 = m_compY[ bottom_j+1 ];
      DenseVector<_Type> result =
        top_row.get_interpolated_vars(compX)*(compY-compY1)/(compY2-compY1)
        + bottom_row.get_interpolated_vars(compX)*(compY2-compY)/(compY2-compY1);
      return result;
    }

References CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_X(), CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::FnComp_Y(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_interpolated_vars(), CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_nodes_vars(), CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_compX, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_compY, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_nv, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_nx, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_ny, and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::set_nodes_vars().

◆ get_nnodes()

template<typename _Type >

std::pair< std::size_t, std::size_t > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_nnodes

Get the number of nodes in the two directions of the 2D mesh.

Returns: A pair consisting of the number of nodes in the 2 directions

Definition at line 163 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                                 {
    std::pair< std::size_t, std::size_t > nodes;
    nodes.first = m_nx;
    nodes.second = m_ny;
    return nodes;
  }

◆ get_nodes_vars()

template<typename _Type >

DenseVector< _Type > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_nodes_vars	(	const std::size_t	nodex,
		const std::size_t	nodey
	)		const

Get the variables stored at A SPECIFIED node – equivalent to mesh(nodex,nodey).

Parameters

nodex	The x nodal index to be returned
nodey	The y nodal index to be returned

Returns: The vector of VARIABLES stored at this nodal point

Definition at line 37 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                                                                    {
#ifdef PARANOID
    if(nodex > m_nx - 1 || nodey > m_ny - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.get_nodes_vars method is trying to \n";
      problem += " access a nodal point that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nx, nodex, m_ny, nodey);
    }
#endif
    // construct a vector with m_nv elements starting from a pointer
    DenseVector<_Type> nodes_vars(m_nv, &m_vars[(nodex * m_ny + nodey) * m_nv ]);
    return nodes_vars;
  }

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_interpolated_vars().

◆ get_nvars()

template<typename _Type >

std::size_t CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_nvars

Get the number of variables that are stored at each node.

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

Definition at line 171 of file TwoD_Mapped_Node_Mesh.cpp.

                                                          {
    return m_nv;
  }

◆ get_xsection_at_xnode()

template<typename _Type >

OneD_Node_Mesh< _Type > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_xsection_at_xnode ( const std::size_t nodex ) const

Get a cross section of the 2D mesh at a specified (constant) x node.

Parameters

nodex The x nodal index at which the cross section is to be taken

Returns: A 1D nodal mesh

Definition at line 52 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                                                       {
    OneD_Node_Mesh<_Type> xsection(m_Y, m_nv);
    for(std::size_t nodey = 0; nodey < m_ny; ++nodey) {
      xsection.set_nodes_vars(nodey, this -> get_nodes_vars(nodex, nodey));
    }
    return xsection;
  }

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

◆ get_xsection_at_ynode()

template<typename _Type >

OneD_Node_Mesh< _Type > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::get_xsection_at_ynode ( const std::size_t nodey ) const

Get a cross section of the 2D mesh at a specified (constant) y node.

Parameters

nodey The y nodal index at which the cross section is to be taken

Returns: A 1D nodal mesh

Definition at line 61 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                                                       {
    OneD_Node_Mesh<_Type> xsection(m_X, m_nv);
    for(std::size_t nodex = 0; nodex < m_nx; ++nodex) {
      xsection.set_nodes_vars(nodex, this -> get_nodes_vars(nodex, nodey));
    }
    return xsection;
  }

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

◆ init_mapping()

template<typename _Type >

void CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::init_mapping

Sometimes a useful mapping is painful to invert analytically.

Here we construct the physical node distribution by finding the set of points x_i such that the computation nodes X satisfy X_i = FnComp_X(x_i), for example.

Definition at line 75 of file TwoD_Mapped_Node_Mesh.cpp.

                                                  {
    #ifdef DEBUG
    std::cout << "[DEBUG] Physical domain is [" << m_left << "," << m_right
              << "] x [" << m_bottom << "," << m_top << "]\n";
    std::cout << "[DEBUG] Computational domain is ["
              << FnComp_X(m_left) << "," << FnComp_X(m_right)
              << "] x [" << FnComp_Y(m_bottom) << "," << FnComp_Y(m_top) << "]\n";
    #endif
    {
      // a uniform mesh in the computational coordinates
      double comp_left(FnComp_X(m_left));
      double comp_right(FnComp_X(m_right));
      const double comp_delta_x = (comp_right - comp_left) / (m_nx - 1);
      for(std::size_t i = 0; i < m_nx; ++i) {
        m_compX[i] = comp_left + comp_delta_x * i;
      }
    }
    {
      // a uniform mesh in the computational coordinates
      double comp_bottom(FnComp_Y(m_bottom));
      double comp_top(FnComp_Y(m_top));
      const double comp_delta_y = (comp_top - comp_bottom) / (m_ny - 1);
      for(std::size_t j = 0; j < m_ny; ++j) {
        m_compY[j] = comp_bottom + comp_delta_y * j;
      }
    }
 
    // temporary fill to span the domain -- corrected below
    m_X = Utility::uniform_node_vector(m_left,m_right,m_nx);
    m_Y = Utility::uniform_node_vector(m_bottom,m_top,m_ny);
    
    // we now need the corresponding m_Y coordinates in the physical domain
    {
      // start and end points are mapped correctly
      for(unsigned j = 1; j < m_ny-1; ++j) {
        // // for each node in m_compY
        // unsigned kmin(0);
        // double min(99e9);
        // for(unsigned k = 0; k < m_ny; ++k) {
        //   // find the y value that is closest to it
        //   if(std::abs(FnComp_Y(m_Y[k]) - m_compY[j]) < min) {
        //     min = std::abs(FnComp_Y(m_Y[k]) - m_compY[j]);
        //     kmin = k;
        //   }
        // }
        double y = m_Y[j-1];
        double delta = 1.e-8;
        double correction = 1.0;
        do {
          double newY = FnComp_Y(y + delta) - m_compY[j];
          double oldY = FnComp_Y(y) - m_compY[j];
          double deriv = (newY-oldY)/delta;
          correction = -oldY/deriv;
          y += correction;
        } while(fabs(correction) > 1.e-8);
        m_Y[ j ] = y;
      }
    }
    
    // we now need the corresponding m_X coordinates in the physical domain
    {
      // start and end are already mapped correctly
      for(unsigned i = 1; i < m_nx-1; ++i) {
        // use the previous point as an approximate guess at current mapping
        double x = m_X[i-1];
        double delta = 1.e-8;
        double correction = 1.0;
        do {
          double newX = FnComp_X(x + delta) - m_compX[i];
          double oldX = FnComp_X(x) - m_compX[i];
          double deriv = (newX-oldX)/delta;
          correction = -oldX/deriv;
          x += correction;
        } while(fabs(correction) > 1.e-8);
        m_X[ i ] = x;
      }
    }
  }

References CppNoddy::Utility::uniform_node_vector().

Referenced by Example::My_Mesh< _Type >::My_Mesh().

◆ max()

template<typename _Type >

double CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::max ( unsigned var )

inline

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 234 of file TwoD_Mapped_Node_Mesh.h.

                             {
      double max(0.0);
      // step through the nodes
      for(unsigned nodex = 0; nodex < m_nx; ++nodex) {
        for(unsigned nodey = 0; nodey < m_ny; ++nodey) {
          if(std::abs(m_vars[(nodex * m_ny + nodey) * m_nv + var ]) > max) {
            max = std::abs(m_vars[(nodex * m_ny + nodey) * m_nv + var ]);
          }
        }
      }
      return max;
    }

References CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_nv, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_nx, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_ny, CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_vars, and CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::max().

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::max().

◆ normalise() [1/3]

template<typename _Type >

void CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::normalise ( const std::size_t & var )

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.

◆ normalise() [2/3]

void CppNoddy::TwoD_Mapped_Node_Mesh< double >::normalise ( const std::size_t & var )

Definition at line 186 of file TwoD_Mapped_Node_Mesh.cpp.

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

◆ normalise() [3/3]

void CppNoddy::TwoD_Mapped_Node_Mesh< D_complex >::normalise ( const std::size_t & var )

Definition at line 192 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                       {
    //std::cout << "[DEBUG] asked to normalise a complex mesh\n";
    unsigned max_nx(0);
    unsigned max_ny(0);
    double max(0.0);
    // step through the nodes
    for(unsigned nodex = 0; nodex < m_X.size(); ++nodex) {
      for(unsigned nodey = 0; nodey < m_Y.size(); ++nodey) {
        if(std::abs(m_vars[(nodex * m_ny + nodey) * m_nv + var ]) > max) {
          max = std::abs(m_vars[(nodex * m_ny + nodey) * m_nv + var ]);
          max_nx = nodex;
          max_ny = nodey;
        }
      }
    }
    D_complex factor(m_vars[(max_nx * m_ny + max_ny) * m_nv + var ]);
    //std::cout << "[DEBUG] MAX |variable| had complex value of " << factor << "\n";
    m_vars.scale(1./factor);
  }

◆ operator()() [1/3]

template<typename _Type >

DenseVector< _Type > CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::operator()	(	const std::size_t	nodex,
		const std::size_t	nodey
	)

inline

Access operator for a nodal point that returns a vector.

Parameters

nodex	The nodal index value in the first direction
nodey	The nodal index value in the second direction

Returns: The vector of variables stored at the node

Definition at line 319 of file TwoD_Mapped_Node_Mesh.h.

                                                                                                                  {
#ifdef PARANOID
    if(nodex > m_nx - 1 || nodey > m_ny - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.operator() method is trying to \n";
      problem += " access a nodal point that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nx, nodex, m_ny, nodey);
    }
#endif
    return get_nodes_vars(nodex,nodey);
  }

◆ operator()() [2/3]

template<typename _Type >

_Type & CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::operator()	(	const std::size_t	nodex,
		const std::size_t	nodey,
		const std::size_t	var
	)

inline

Access operator for a nodal point/variable in the mesh.

Parameters

nodex	The nodal index value in the first direction
nodey	The nodal index value in the second direction
var	The variable index to be accessed

Definition at line 333 of file TwoD_Mapped_Node_Mesh.h.

                                                                                                                          {
#ifdef PARANOID
    if(nodex > m_nx - 1 || nodey > m_ny - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.operator() method is trying to \n";
      problem += " access a nodal point that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nx, nodex, m_ny, nodey);
    }
    if(var > m_nv - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.operator() method is trying to \n";
      problem += " access a variable index that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nv, var);
    }
#endif
    return m_vars[(nodex * m_ny + nodey) * m_nv + var ];
  }

◆ operator()() [3/3]

template<typename _Type >

const _Type & CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::operator()	(	const std::size_t	nodex,
		const std::size_t	nodey,
		const std::size_t	var
	)		const

inline

Const access operator for a nodal point/variable in the mesh.

Parameters

nodex	The nodal index value in the first direction
nodey	The nodal index value in the second direction
var	The variable index to be accessed

Definition at line 352 of file TwoD_Mapped_Node_Mesh.h.

                                                                                                                                      {
#ifdef PARANOID
    if(nodex > m_nx - 1 || nodey > m_ny - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.operator() method is trying to \n";
      problem += " access a nodal point that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nx, nodex, m_ny, nodey);
    }
    if(var > m_nv - 1) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.operator() method is trying to \n";
      problem += " access a variable index that is not in the mesh. \n";
      throw ExceptionRange(problem, m_nv, var);
    }
#endif
    return m_vars[(nodex * m_ny + nodey) * m_nv + var ];
  }

◆ read() [1/3]

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

Definition at line 213 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                         {
    std::ifstream dump;
    dump.open(filename.c_str());
    if(dump.good() != true) {
      std::string problem;
      problem = " The TwoD_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);
    for(std::size_t i = 0; i < m_nx; ++i) {
      for(std::size_t j = 0; j < m_ny; ++j) {
        double x, y;
        dump >> x;
        dump >> y;
        for(std::size_t var = 0; var < m_nv; ++var) {
          double value;
          dump >> value;
          m_vars[(i * m_ny + j) * 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::fabs(y - m_Y[ j ]) > 1.e-6)) {
            std::cout << " Read x = " << x << " Expected x = " << m_X[ i ] << "; Read y = " << y << " Expected y = " << m_Y[ j ] << " \n";
            std::cout << " Absolute differences are " << fabs(x - m_X[i]) << " and " << fabs(y - m_Y[j]) << "\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;
          m_Y[ j ] = y;
        }
      }
    }
  }

◆ read() [2/3]

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

Definition at line 256 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                            {
    std::ifstream dump;
    dump.open(filename.c_str());
    dump.precision(15);
    dump.setf(std::ios::showpoint);
    dump.setf(std::ios::showpos);
    dump.setf(std::ios::scientific);
    //
    // 18/06/2017: switched i and j below for consistency with double
    //
    for(std::size_t i = 0; i < m_nx; ++i) {
      for(std::size_t j = 0; j < m_ny; ++j) {
        double x, y;
        dump >> x;
        dump >> y;
        for(std::size_t var = 0; var < m_nv; ++var) {
          double value_r, value_i;
          dump >> value_r;
          dump >> value_i;
          m_vars[(i * m_ny + j) * m_nv + var ] = D_complex(value_r, value_i);
        }
        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::fabs(y - m_Y[ j ]) > 1.e-6)) {
            std::cout << " Read x = " << x << " Expected x = " << m_X[ i ] << "; Read y = " << y << " Expected y = " << m_Y[ j ] << " \n";
            std::cout << " Absolute differences are " << fabs(x - m_X[i]) << " and " << fabs(y - m_Y[j]) << "\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;
          m_Y[ j ] = y;
        }
      }
    }
  }

◆ read() [3/3]

template<typename _Type >

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

A simple method for reading data from a file.

Parameters

filename	The filename to write the data to (will overwrite)
reset	Will reset the nodal positions using those from the file

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::TwoD_Mapped_Node_Mesh().

◆ scale()

template<typename _Type >

void CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::scale ( const _Type & value )

inline

Rescale all values stored in the mapped mesh by a scalar.

Parameters

value The scalar that is to multiply all mesh content

Definition at line 226 of file TwoD_Mapped_Node_Mesh.h.

                                   {
      m_vars.scale(value);
    }

References CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::m_vars.

◆ set_nodes_vars()

template<typename _Type >

void CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::set_nodes_vars	(	const std::size_t	nodex,
		const std::size_t	nodey,
		const DenseVector< _Type > &	U
	)

Set the variables stored at A SPECIFIED node.

Parameters

nodex	The x nodal index to be set
nodey	The y nodal index to be set
U	The vector of VARIABLES to be written to this nodal point

Definition at line 20 of file TwoD_Mapped_Node_Mesh.cpp.

                                                                                                                             {
#ifdef PARANOID
    if(U.size() > m_nv) {
      std::string problem;
      problem = " The TwoD_Mapped_Node_Mesh.set_nodes_vars method is trying to use a \n";
      problem += " vector that has more entries than variables stored in the mesh. \n";
      throw ExceptionRuntime(problem);
    }
#endif
    // assign contents of U to the member data
    std::size_t offset((nodex * m_ny + nodey) * m_nv);
    for(std::size_t var = 0; var < m_nv; ++var) {
      m_vars[ offset++ ] = U[ var ];
    }
  }

References U.

◆ xnodes()

template<typename _Type >

DenseVector< double > & CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::xnodes

Access the vector of x-nodal positions.

Returns: A vector of the nodal positions for this mesh

Definition at line 176 of file TwoD_Mapped_Node_Mesh.cpp.

                                                            {
    return m_X;
  }

◆ ynodes()

template<typename _Type >

DenseVector< double > & CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::ynodes

Access the vector of y-nodal positions.

Returns: A vector of the nodal positions for this mesh

Definition at line 181 of file TwoD_Mapped_Node_Mesh.cpp.

                                                            {
    return m_Y;
  }

Referenced by CppNoddy::TwoD_Mapped_Node_Mesh< _Type >::TwoD_Mapped_Node_Mesh().

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

include/TwoD_Mapped_Node_Mesh.h
src/TwoD_Mapped_Node_Mesh.cpp

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TwoD_Mapped_Node_Mesh() [1/3]

◆ TwoD_Mapped_Node_Mesh() [2/3]

◆ TwoD_Mapped_Node_Mesh() [3/3]

◆ ~TwoD_Mapped_Node_Mesh()

Member Function Documentation

◆ coord()

◆ dump_gnu() [1/3]

◆ dump_gnu() [2/3]

◆ dump_gnu() [3/3]

◆ FnComp_X()

◆ FnComp_Xd()

◆ FnComp_Xdd()

◆ FnComp_Y()

◆ FnComp_Yd()

◆ FnComp_Ydd()

◆ get_comp_step_sizes()

◆ get_interpolated_vars()

◆ get_nnodes()

◆ get_nodes_vars()

◆ get_nvars()

◆ get_xsection_at_xnode()

◆ get_xsection_at_ynode()

◆ init_mapping()

◆ max()

◆ normalise() [1/3]

◆ normalise() [2/3]

◆ normalise() [3/3]

◆ operator()() [1/3]

◆ operator()() [2/3]

◆ operator()() [3/3]

◆ read() [1/3]

◆ read() [2/3]

◆ read() [3/3]

◆ scale()

◆ set_nodes_vars()

◆ xnodes()

◆ ynodes()

Member Data Documentation

◆ m_bottom

◆ m_compX

◆ m_compY

◆ m_left

◆ m_nv

◆ m_nx

◆ m_ny

◆ m_right

◆ m_top

◆ m_vars

◆ m_X

◆ m_Y