quadgrid_t< distributed_vector > Class Template Reference

#include <quadgrid_cpp.h>

Classes
struct	grid_properties_t
class	cell_iterator
class	neighbor_iterator
class	cell_t

Public Types
using	idx_t = int

Public Member Functions
void	from_json (const nlohmann::json &j, grid_properties_t &q)
	quadgrid_t (MPI_Comm _comm=MPI_COMM_WORLD)
	Default constructor, set all pointers to nullptr.
	quadgrid_t (const nlohmann::json &j, MPI_Comm _comm=MPI_COMM_WORLD)
	Ctor that reads grid properties from a json object.
	quadgrid_t (const quadgrid_t &)=delete
	Delete copy constructor.
quadgrid_t &	operator= (const quadgrid_t &)=delete
	Delete assignment operator.
	~quadgrid_t ()=default
	Destructor.
void	set_sizes (idx_t numrows, idx_t numcols, real_t hx, real_t hy)
void	vtk_export (const char *filename, const std::map< std::string, distributed_vector > &f) const
void	octave_ascii_export (const char *filename, const std::map< std::string, distributed_vector > &f) const
cell_iterator	begin_cell_sweep ()
const cell_iterator	begin_cell_sweep () const
cell_iterator	end_cell_sweep ()
const cell_iterator	end_cell_sweep () const
idx_t	num_owned_nodes ()
idx_t	num_local_nodes () const
idx_t	num_global_nodes () const
idx_t	num_local_cells () const
idx_t	num_global_cells () const
idx_t	num_rows () const
idx_t	num_cols () const
real_t	hx () const
real_t	hy () const
idx_t	sub2gind (idx_t r, idx_t c) const
idx_t	gind2row (idx_t idx) const
idx_t	gind2col (idx_t idx) const
const cell_t &	operator[] (idx_t tmp) const

Static Public Member Functions
HOST static DEVICE idx_t	gind2col (idx_t idx, idx_t numrows)
HOST static DEVICE idx_t	gind2row (idx_t idx, idx_t numrows)
HOST static DEVICE idx_t	gt (idx_t inode, idx_t cidx, idx_t ridx, idx_t numrows)
HOST static DEVICE real_t	p (idx_t idir, idx_t inode, idx_t colidx, idx_t rowidx, real_t hx, real_t hy)
HOST static DEVICE real_t	shp (real_t x, real_t y, idx_t inode, idx_t c, idx_t r, real_t hx, real_t hy)
HOST static DEVICE real_t	shg (real_t x, real_t y, idx_t idir, idx_t inode, idx_t c, idx_t r, real_t hx, real_t hy)
HOST static DEVICE idx_t	sub2gind (idx_t r, idx_t c, idx_t nr)

Public Attributes
MPI_Comm	comm
int	rank
int	size

Private Attributes
cell_t	current_cell
cell_t	current_neighbor
grid_properties_t	grid_properties

Detailed Description

template<class distributed_vector>
class quadgrid_t< distributed_vector >

Definition at line 13 of file quadgrid_cpp.h.

Member Typedef Documentation

idx_t

template<class distributed_vector>

using quadgrid_t< distributed_vector >::idx_t = int

Definition at line 19 of file quadgrid_cpp.h.

Constructor & Destructor Documentation

quadgrid_t() [1/3]

template<class distributed_vector>

quadgrid_t< distributed_vector >::quadgrid_t ( MPI_Comm _comm = MPI_COMM_WORLD )

inline

Default constructor, set all pointers to nullptr.

Definition at line 408 of file quadgrid_cpp.h.

                                             :
    comm (_comm), rank (0), size (1),
    current_cell (grid_properties),
    current_neighbor (grid_properties)
  {
    int flag = 0;
    MPI_Initialized (&flag);
    if (flag) {
      MPI_Comm_rank (comm, &rank);
      MPI_Comm_size (comm, &size);
    } else {
      rank = 0;
      size = 1;
    }
    grid_properties.numrows = 0;
    grid_properties.numcols = 0;
    grid_properties.hx = 0.;
    grid_properties.hy = 0.;
    grid_properties.start_cell_row = 0;
    grid_properties.end_cell_row = 0;
    grid_properties.start_cell_col = 0;
    grid_properties.end_cell_col = 0;
    grid_properties.start_owned_nodes = 0;
    grid_properties.num_owned_nodes = 0;
  };

quadgrid_t() [2/3]

template<class distributed_vector>

quadgrid_t< distributed_vector >::quadgrid_t ( const nlohmann::json & j, MPI_Comm _comm = MPI_COMM_WORLD )

inline

Ctor that reads grid properties from a json object.

Definition at line 435 of file quadgrid_cpp.h.

                                                                    :
    quadgrid_t(_comm) { from_json (j, grid_properties); };

quadgrid_t() [3/3]

template<class distributed_vector>

quadgrid_t< distributed_vector >::quadgrid_t ( const quadgrid_t< distributed_vector > & )

delete

Delete copy constructor.

~quadgrid_t()

template<class distributed_vector>

quadgrid_t< distributed_vector >::~quadgrid_t ( )

default

Destructor.

Member Function Documentation

begin_cell_sweep() [1/2]

template<class T>

quadgrid_t< T >::cell_iterator quadgrid_t< T >::begin_cell_sweep

(

)

Definition at line 4 of file quadgrid_cpp_imp.h.

                                 {
  current_cell.reset ();
  return cell_iterator (&current_cell);
}

begin_cell_sweep() [2/2]

template<class T>

const quadgrid_t< T >::cell_iterator quadgrid_t< T >::begin_cell_sweep

(

)

const

Definition at line 13 of file quadgrid_cpp_imp.h.

                                       {
  current_cell.reset ();
  return cell_iterator (&current_cell);
}

end_cell_sweep() [1/2]

template<class distributed_vector>

cell_iterator quadgrid_t< distributed_vector >::end_cell_sweep ( )

inline

Definition at line 469 of file quadgrid_cpp.h.

  { return cell_iterator (); };

end_cell_sweep() [2/2]

template<class distributed_vector>

const cell_iterator quadgrid_t< distributed_vector >::end_cell_sweep ( ) const

inline

Definition at line 473 of file quadgrid_cpp.h.

  { return cell_iterator (); };

from_json()

template<class distributed_vector>

void quadgrid_t< distributed_vector >::from_json ( const nlohmann::json & j, grid_properties_t & q )

inline

Definition at line 36 of file quadgrid_cpp.h.

                                                          {
 
    j.at ("nx").get_to (q.numcols);
    j.at ("ny").get_to (q.numrows);
    j.at ("hx").get_to (q.hx);
    j.at ("hy").get_to (q.hy);
 
 
    q.start_cell_row = 0;
    q.end_cell_row = q.numrows - 1;
    q.start_cell_col = 0;
    q.end_cell_col = q.numcols - 1;
    q.start_owned_nodes = 0;
    q.num_owned_nodes = (q.numrows+1)*(q.numcols+1);
 
  }

gind2col() [1/2]

template<class distributed_vector>

idx_t quadgrid_t< distributed_vector >::gind2col ( idx_t idx ) const

inline

Definition at line 519 of file quadgrid_cpp.h.

                             {
    return quadgrid_t:: gind2col (idx, grid_properties.numrows);
  }

gind2col() [2/2]

template<class distributed_vector>

HOST static DEVICE idx_t quadgrid_t< distributed_vector >::gind2col ( idx_t idx, idx_t numrows )

inlinestatic

Definition at line 55 of file quadgrid_cpp.h.

                                      {
    return (idx / numrows);
  }

gind2row() [1/2]

template<class distributed_vector>

idx_t quadgrid_t< distributed_vector >::gind2row ( idx_t idx ) const

inline

Definition at line 514 of file quadgrid_cpp.h.

                             {
    return quadgrid_t:: gind2row (idx, grid_properties.numrows);
  }

gind2row() [2/2]

template<class distributed_vector>

HOST static DEVICE idx_t quadgrid_t< distributed_vector >::gind2row ( idx_t idx, idx_t numrows )

inlinestatic

Definition at line 61 of file quadgrid_cpp.h.

                                      {
    return  (idx % numrows);
  }

gt()

template<class distributed_vector>

HOST static DEVICE idx_t quadgrid_t< distributed_vector >::gt ( idx_t inode, idx_t cidx, idx_t ridx, idx_t numrows )

inlinestatic

Definition at line 67 of file quadgrid_cpp.h.

                                                          {
    idx_t bottom_left = 0;
    // should check that inode < 4 in an efficient way
    bottom_left =  ridx + cidx * (numrows + 1);
    switch (inode) {
    case 0 :
      return (bottom_left);
      break;
    case 1 :
      return (bottom_left + 1);
      break;
    case 2 :
      return (bottom_left + (numrows + 1));
      break;
    case 3 :
      return (bottom_left + (numrows + 2));
      break;
    default :
      return -1;
    }
  }

hx()

template<class distributed_vector>

real_t quadgrid_t< distributed_vector >::hx ( ) const

inline

Definition at line 501 of file quadgrid_cpp.h.

  { return grid_properties.hx; };

hy()

template<class distributed_vector>

real_t quadgrid_t< distributed_vector >::hy ( ) const

inline

Definition at line 505 of file quadgrid_cpp.h.

  { return grid_properties.hy; };

num_cols()

template<class distributed_vector>

idx_t quadgrid_t< distributed_vector >::num_cols ( ) const

inline

Definition at line 497 of file quadgrid_cpp.h.

  { return grid_properties.numcols; };

num_global_cells()

template<class T>

quadgrid_t< T >::idx_t quadgrid_t< T >::num_global_cells

(

)

const

Definition at line 145 of file quadgrid_cpp_imp.h.

                                       {
  return grid_properties.numrows*grid_properties.numcols;
}

num_global_nodes()

template<class T>

quadgrid_t< T >::idx_t quadgrid_t< T >::num_global_nodes

(

)

const

Definition at line 154 of file quadgrid_cpp_imp.h.

                                       {
  return (grid_properties.numrows+1)*(grid_properties.numcols+1);
}

num_local_cells()

template<class T>

quadgrid_t< T >::idx_t quadgrid_t< T >::num_local_cells

(

)

const

Definition at line 136 of file quadgrid_cpp_imp.h.

                                      {
  return grid_properties.numrows*grid_properties.numcols;
}

num_local_nodes()

template<class T>

quadgrid_t< T >::idx_t quadgrid_t< T >::num_local_nodes

(

)

const

Definition at line 160 of file quadgrid_cpp_imp.h.

                                      {
  return (grid_properties.numrows+1)*(grid_properties.numcols+1);
}

num_owned_nodes()

template<class distributed_vector>

idx_t quadgrid_t< distributed_vector >::num_owned_nodes ( )

inline

Definition at line 477 of file quadgrid_cpp.h.

  { return grid_properties.num_owned_nodes; };

num_rows()

template<class distributed_vector>

idx_t quadgrid_t< distributed_vector >::num_rows ( ) const

inline

Definition at line 493 of file quadgrid_cpp.h.

  { return grid_properties.numrows; };

octave_ascii_export()

template<class distributed_vector>

void quadgrid_t< T >::octave_ascii_export	(	const char *	filename,
		const std::map< std::string, distributed_vector > &	f ) const

Definition at line 395 of file quadgrid_cpp_imp.h.

                                          {
 
  std::ofstream os (filename, std::ofstream::out);
 
  os << "# name: p" << std::endl
     << "# type: matrix" << std::endl
     << "# rows: 2" << std::endl
     << "# columns: " << num_owned_nodes () << std::endl;
 
  for (idx_t jj = 0; jj < num_cols () + 1; ++jj) {
    for (idx_t ii = 0; ii < num_rows () + 1; ++ii) {
      os  << std::setprecision(16) << jj*hx() << " ";
    }
  }
  os << std::endl;
 
  for (idx_t jj = 0; jj < num_cols () + 1; ++jj) {
    for (idx_t ii = 0; ii < num_rows () + 1; ++ii) {
      os  << std::setprecision(16) << ii*hy() << " ";
    }
  }
  os << std::endl;
 
  os << "# name: t" << std::endl
     << "# type: matrix" << std::endl
     << "# rows: 4" << std::endl
     << "# columns: " << num_local_cells () << std::endl;
  for (auto inode = 0;
       inode < quadgrid_t<vector_t<real_t>>::cell_t::nodes_per_cell;
       ++inode) {
    for (auto icell = begin_cell_sweep ();
         icell != end_cell_sweep (); ++icell) {
      os  << std::setprecision(16) << icell->gt(inode) << " ";
    }
    os << std::endl;
  }
 
 
  os << "# name: vars" << std::endl
     << "# type: scalar struct" << std::endl
     << "# ndims: 2" << std::endl
     << "1 1" << std::endl
     << "# length: " << vars.size () << std::endl;
 
 
  for (auto const & ii : vars) {
    os << "# name: " << ii.first << std::endl
       << "# type: matrix" << std::endl
       << "# rows: 1" << std::endl
       << "# columns: " << ii.second.size () << std::endl;
    for (auto const & kk : ii.second) {
      os << std::setprecision(16) << kk << " ";
    }
    os << std::endl;
  }
  os << std::endl;
 
  os.close ();
}

operator=()

template<class distributed_vector>

quadgrid_t & quadgrid_t< distributed_vector >::operator= ( const quadgrid_t< distributed_vector > & )

delete

Delete assignment operator.

operator[]()

template<class T>

const quadgrid_t< T >::cell_t & quadgrid_t< T >::operator[]

(

idx_t

tmp

)

const

Definition at line 60 of file quadgrid_cpp_imp.h.

                                          {
  assert (tmp <= (current_cell.end_cell_row () +
                  current_cell.num_rows () * current_cell.end_cell_col ()));
  current_cell.rowidx = tmp % current_cell.num_rows ();
  current_cell.colidx = tmp / current_cell.num_rows ();
  current_cell.global_cell_idx = tmp;
  current_cell.local_cell_idx = tmp -
    (current_cell.start_cell_row () +
     current_cell.num_rows () * current_cell.start_cell_col ());
  return current_cell;
};

p()

template<class distributed_vector>

HOST static DEVICE real_t quadgrid_t< distributed_vector >::p ( idx_t idir, idx_t inode, idx_t colidx, idx_t rowidx, real_t hx, real_t hy )

inlinestatic

Definition at line 111 of file quadgrid_cpp.h.

                                                                                {
    real_t bottom_left = 0.0;
    // should check that inode < 4 in an efficient way
    if (idir == 0) {
      bottom_left = colidx * hx;
      if (inode > 1)
    bottom_left += hx;
    } else {
      bottom_left = rowidx * hy;
      if (inode == 1 || inode == 3)
    bottom_left += hy;
    }
    return (bottom_left);
  }

set_sizes()

template<class T>

void quadgrid_t< T >::set_sizes	(	idx_t	numrows,
		idx_t	numcols,
		real_t	hx,
		real_t	hy )

Definition at line 22 of file quadgrid_cpp_imp.h.

                                                {
  grid_properties.numrows = numrows;
  grid_properties.numcols = numcols;
  grid_properties.hx = hx;
  grid_properties.hy = hy;
  grid_properties.start_cell_row = 0;
  grid_properties.end_cell_row = numrows - 1;
  grid_properties.start_cell_col = 0;
  grid_properties.end_cell_col = numcols - 1;
  grid_properties.start_owned_nodes = 0;
  grid_properties.num_owned_nodes = (numrows+1)*(numcols+1);
}

shg()

template<class distributed_vector>

HOST static DEVICE real_t quadgrid_t< distributed_vector >::shg ( real_t x, real_t y, idx_t idir, idx_t inode, idx_t c, idx_t r, real_t hx, real_t hy )

inlinestatic

Definition at line 152 of file quadgrid_cpp.h.

                                               {
    switch (inode) {
    case 3 :
      if (idir == 0) {
    return ((1. / hx) * ((y - p(1,0,c,r,hx,hy)) / hy));
      }
      else if (idir == 1) {
    return (((x - p(0,0,c,r,hx,hy)) / hx) * (1. / hy));
      }
      break;
    case 2 :
      if (idir == 0) {
    return ((1. / hx) * ((1. - (y - p(1,0,c,r,hx,hy)) / hy)));
      }
      else if (idir == 1) {
    return (((x - p(0,0,c,r,hx,hy)) / hx) * (- 1. / hy));
      }
      break;
    case 1 :
      if (idir == 0) {
    return ((- 1. / hx) * ((y - p(1,0,c,r,hx,hy)) / hy));
      }
      else if (idir == 1) {
    return ((1. - (x - p(0,0,c,r,hx,hy)) / hx) * (1. / hy));
      }
      break;
    case 0 :
      if (idir == 0) {
    return ((- 1. / hx) * (1. - (y - p(1,0,c,r,hx,hy)) / hy));
      }
      else if (idir == 1) {
    return ((1. - (x - p(0,0,c,r,hx,hy))/ hx) * (- 1. / hy));
      }
      break;
    }
    return 0.;
  };

shp()

template<class distributed_vector>

HOST static DEVICE real_t quadgrid_t< distributed_vector >::shp ( real_t x, real_t y, idx_t inode, idx_t c, idx_t r, real_t hx, real_t hy )

inlinestatic

Definition at line 128 of file quadgrid_cpp.h.

                                               {
 
    switch (inode) {
    case 3 :
      return ((x - p(0,0,c,r,hx,hy))/hx * (y - p(1,0,c,r,hx,hy))/hy);
      break;
    case 2 :
      return ((x - p(0,0,c,r,hx,hy))/hx * (1. - (y - p(1,0,c,r,hx,hy))/hy));
      break;
    case 1 :
      return ((1. - (x - p(0,0,c,r,hx,hy))/hx) * (y - p(1,0,c,r,hx,hy))/hy);
      break;
    case 0 :
      return ((1. - (x - p(0,0,c,r,hx,hy))/hx) * (1. - (y - p(1,0,c,r,hx,hy))/hy));
      break;
    default :
      return 0;
    }
    
  }

sub2gind() [1/2]

template<class distributed_vector>

idx_t quadgrid_t< distributed_vector >::sub2gind ( idx_t r, idx_t c ) const

inline

Definition at line 509 of file quadgrid_cpp.h.

                                    {
    return  (r + grid_properties.numrows * c);
  }

sub2gind() [2/2]

template<class distributed_vector>

HOST static DEVICE idx_t quadgrid_t< distributed_vector >::sub2gind ( idx_t r, idx_t c, idx_t nr )

inlinestatic

Definition at line 193 of file quadgrid_cpp.h.

                                        {
    return  (r + nr * c);
  }

vtk_export()

template<class distributed_vector>

void quadgrid_t< T >::vtk_export	(	const char *	filename,
		const std::map< std::string, distributed_vector > &	f ) const

Definition at line 345 of file quadgrid_cpp_imp.h.

                                                                 {
 
  std::ofstream ofs (filename, std::ofstream::out);
 
  // This is the XML format of a VTS file to write :
 
  ofs <<
    "<VTKFile type=\"StructuredGrid\" version=\"StructuredGrid\" byte_order=\"LittleEndian\">\n\
    <StructuredGrid WholeExtent=\"0 " << num_rows() << " 0 " << num_cols() << " 0 0\">\n \
      <Piece Extent=\"0 " << num_rows() << " 0 " << num_cols() << " 0 0\">\n";
 
  ofs << "      <PointData Scalars=\"";
  for (auto const & ii : f) {
    ofs << ii.first << ",";
  }
  ofs  << "\">\n";
 
  for (auto const & ii : f) {
    ofs << "        <DataArray type=\"Float64\" Name=\"" << ii.first <<"\" format=\"ascii\">\n        ";
    for (auto const & jj : ii.second) {
      ofs << jj << " ";
    }
    ofs << std::endl << "        </DataArray>" << std::endl;
  }
 
  ofs << "      </PointData>\n";
 
  ofs << "      <Points>\n        <DataArray type=\"Float64\" NumberOfComponents=\"3\" format=\"ascii\">\n";
  for (idx_t ii = 0; ii <= num_cols(); ++ii) {
    ofs << "          ";
    for (idx_t jj = 0; jj <= num_rows(); ++jj) {
      ofs << std::setprecision(16) << hx()*ii << " " << hy()*jj << " 0 ";
    }
    ofs << std::endl;
  }
  ofs << "        </DataArray>\n      </Points>\n";
 
 
  ofs <<
    "    </Piece>\n\
  </StructuredGrid>\n\
</VTKFile>\n";
 
  ofs.close ();
}

Member Data Documentation

comm

template<class distributed_vector>

MPI_Comm quadgrid_t< distributed_vector >::comm

Definition at line 526 of file quadgrid_cpp.h.

current_cell

template<class distributed_vector>

cell_t quadgrid_t< distributed_vector >::current_cell

mutableprivate

Definition at line 532 of file quadgrid_cpp.h.

current_neighbor

template<class distributed_vector>

cell_t quadgrid_t< distributed_vector >::current_neighbor

mutableprivate

Definition at line 533 of file quadgrid_cpp.h.

grid_properties

template<class distributed_vector>

grid_properties_t quadgrid_t< distributed_vector >::grid_properties

private

Definition at line 535 of file quadgrid_cpp.h.

rank

template<class distributed_vector>

int quadgrid_t< distributed_vector >::rank

Definition at line 527 of file quadgrid_cpp.h.

size

template<class distributed_vector>

int quadgrid_t< distributed_vector >::size

Definition at line 528 of file quadgrid_cpp.h.

---

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

• quadgrid_cpp.h
• quadgrid_cpp_imp.h