atlas::StructuredGrid class
#include <atlas/grid/StructuredGrid.h>

Specialization of Grid, where the grid can be represented by rows with uniform distribution.

                                   Grid
                                     |
                          +----------+----------+
                          |                     |
                   StructuredGrid        UnstructuredGrid
                          |
     +--------------------+-----------------------+
     |                    |                       |
ReducedGrid          GaussianGrid            RegularGrid
     |                 |     |                 |     |
     +--------+--------+     +--------+--------+     +-----+
              |                       |                    |
     ReducedGaussianGrid     RegularGaussianGrid    RegularLonLatGrid

Base classes

class Grid
Most general grid container.

Derived classes

template<class Grid>
class Gaussian
class HealpixGrid
Specialization of StructuredGrid, assuming a global domain.
class ReducedGrid
Specialization of StructuredGrid, where not all rows have the same number of grid points.
class RegularGrid
Specialization of StructuredGrid, where all rows have the same number of grid points.

Public types

using grid_t = grid::detail::grid::Structured
using XSpace = grid_t::XSpace
using YSpace = grid_t::YSpace
using Config = util::Config
using Spec = util::Config
using Domain = atlas::Domain
using Projection = atlas::Projection
using PointXY = atlas::PointXY
using PointLonLat = atlas::PointLonLat
using IterateXY = grid::IterateXY
using IterateLonLat = grid::IterateLonLat

Constructors, destructors, conversion operators

StructuredGrid()
StructuredGrid(const Grid&)
StructuredGrid(const Grid::Implementation*)
StructuredGrid(const std::string& name, const Domain& = Domain())
StructuredGrid(const std::string& name, const Projection&, const Domain& = Domain())
StructuredGrid(const Config&)
StructuredGrid(const XSpace&, const YSpace&, const Projection& = Projection(), const Domain& = Domain())
StructuredGrid(const Grid&, const Domain&)
operator bool() const

Public functions

auto valid() const -> bool
auto ny() const -> idx_t
auto nx(idx_t j) const -> idx_t
auto nx() const -> const std::vector<idx_t>&
auto nxmax() const -> idx_t
auto y() const -> const std::vector<double>&
auto x(idx_t i, idx_t j) const -> double
x coordinate for given grid point {i,j}
auto y(idx_t j) const -> double
y coordinate for given grid row {j}
auto dx(idx_t j) const -> double
increment in x for a given grid row {j}
auto xmin(idx_t j) const -> double
x coordinate of beginning of a given grid row {j}
void xy(idx_t i, idx_t j, double xy[]) const
void lonlat(idx_t i, idx_t j, double lonlat[]) const
auto xy(idx_t i, idx_t j) const -> PointXY
auto lonlat(idx_t i, idx_t j) const -> PointLonLat
auto reduced() const -> bool
auto regular() const -> bool
auto periodic() const -> bool
auto xspace() const -> const XSpace&
auto yspace() const -> const YSpace&
auto index(idx_t i, idx_t j) const -> gidx_t
void index2ij(gidx_t gidx, idx_t& i, idx_t& j) const
auto xy() const -> IterateXY
auto lonlat() const -> IterateLonLat
auto xy() const -> IterateXY
auto lonlat() const -> IterateLonLat
auto operator==(const Grid& other) const -> bool
auto operator!=(const Grid& other) const -> bool
auto size() const -> idx_t
auto projection() const -> const Projection&
auto domain() const -> const Domain&
auto lonlatBoundingBox() const -> RectangularLonLatDomain
auto name() const -> std::string
auto type() const -> std::string
auto uid() const -> std::string
void hash(eckit::Hash& h) const
Adds to the hash the information that makes this Grid unique.
auto footprint() const -> size_t
auto spec() const -> Spec
auto meshgenerator() const -> Config
auto partitioner() const -> Config

Typedef documentation

using atlas::StructuredGrid::Config = util::Config
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::Spec = util::Config
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::Domain = atlas::Domain
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::Projection = atlas::Projection
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::PointXY = atlas::PointXY
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::PointLonLat = atlas::PointLonLat
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::IterateXY = grid::IterateXY
#include <atlas/grid/Grid.h>

using atlas::StructuredGrid::IterateLonLat = grid::IterateLonLat
#include <atlas/grid/Grid.h>

Function documentation

IterateXY atlas::StructuredGrid::xy() const
#include <atlas/grid/Grid.h>

IterateLonLat atlas::StructuredGrid::lonlat() const
#include <atlas/grid/Grid.h>

bool atlas::StructuredGrid::operator==(const Grid& other) const
#include <atlas/grid/Grid.h>

bool atlas::StructuredGrid::operator!=(const Grid& other) const
#include <atlas/grid/Grid.h>

idx_t atlas::StructuredGrid::size() const
#include <atlas/grid/Grid.h>

const Projection& atlas::StructuredGrid::projection() const
#include <atlas/grid/Grid.h>

const Domain& atlas::StructuredGrid::domain() const
#include <atlas/grid/Grid.h>

RectangularLonLatDomain atlas::StructuredGrid::lonlatBoundingBox() const
#include <atlas/grid/Grid.h>

std::string atlas::StructuredGrid::name() const
#include <atlas/grid/Grid.h>

std::string atlas::StructuredGrid::type() const
#include <atlas/grid/Grid.h>

std::string atlas::StructuredGrid::uid() const
#include <atlas/grid/Grid.h>

void atlas::StructuredGrid::hash(eckit::Hash& h) const
#include <atlas/grid/Grid.h>

Adds to the hash the information that makes this Grid unique.

size_t atlas::StructuredGrid::footprint() const
#include <atlas/grid/Grid.h>

Spec atlas::StructuredGrid::spec() const
#include <atlas/grid/Grid.h>

Config atlas::StructuredGrid::meshgenerator() const
#include <atlas/grid/Grid.h>

Config atlas::StructuredGrid::partitioner() const
#include <atlas/grid/Grid.h>