IceGrid Class Reference

Describes the PISM grid and the distribution of data across processors. More...

#include <grid.hh>

Public Member Functions
	IceGrid (MPI_Comm c, PetscMPIInt r, PetscMPIInt s, const NCConfigVariable &config)
	~IceGrid ()
PetscErrorCode	createDA ()
	Create the PETSc DA `da2` for the horizontal grid. Determine how the horizontal grid is divided among processors.
PetscErrorCode	createDA (PetscInt procs_x, PetscInt procs_y, PetscInt &lx, PetscInt &ly)
PetscErrorCode	set_vertical_levels (int Mz, int Mbz, double z_levels, double zb_levels)
	Sets grid vertical levels, Mz, Mbz, Lz and Lbz. Checks input for consistency.
PetscErrorCode	compute_vertical_levels ()
	Compute vertical levels in both ice and bedrock.
PetscErrorCode	compute_ice_vertical_levels ()
	Set the vertical levels in the ice according to values in Mz, Lz, and the ice_vertical_spacing data member.
PetscErrorCode	compute_bed_vertical_levels ()
	Compute vertical levels in the bedrock.
PetscErrorCode	compute_horizontal_spacing ()
	Compute horizontal spacing parameters `dx` and `dy` using `Mx`, `My`, `Lx`, `Ly` and periodicity.
PetscErrorCode	compute_horizontal_coordinates (double &x, double &y)
	Computes values of x and y corresponding to the computational grid, with accounting for periodicity.
PetscErrorCode	printInfo (int verbosity)
	Print to stdout information on computational domain and grid (other than the vertical levels themselves).
PetscErrorCode	printVertLevels (int verbosity)
	Print the vertical levels in `zlevels`[] and `zblevels`[] to stdout.
PetscInt	kBelowHeight (PetscScalar height)
	Return the index `k` into `zlevels`[] so that `zlevels[k] <= height < zlevels[k+1]` and `k < Mz`.
Public Attributes
MPI_Comm	com
PetscMPIInt	rank
PetscMPIInt	size
DA	da2
PetscInt	xs
PetscInt	xm
PetscInt	ys
PetscInt	ym
PetscScalar *	zlevels
PetscScalar *	zblevels
PetscScalar *	zlevels_fine
PetscScalar *	zblevels_fine
PetscScalar	dz_fine
PetscInt	Mz_fine
PetscInt	Mbz_fine
PetscInt *	ice_storage2fine
PetscInt *	ice_fine2storage
PetscInt *	bed_storage2fine
PetscInt *	bed_fine2storage
SpacingType	ice_vertical_spacing
SpacingType	bed_vertical_spacing
Periodicity	periodicity
PetscScalar	dzMIN
PetscScalar	dzMAX
PetscScalar	dzbMIN
PetscScalar	dzbMAX
PetscScalar	x0
PetscScalar	y0
PetscScalar	Lx
PetscScalar	Ly
PetscInt	Mx
PetscInt	My
PetscInt	Nx
PetscInt	Ny
PetscScalar	dx
PetscScalar	dy
PetscScalar	Lz
PetscScalar	Lbz
PetscInt	Mz
PetscInt	Mbz
PetscInt	initial_Mz
PetscScalar	year
	current time (years)
PetscScalar	start_year
	the year this run started from
PetscScalar	end_year
	time to stop at
Protected Attributes
PetscScalar	lambda
Private Member Functions
void	compute_nprocs ()
PetscErrorCode	get_dzMIN_dzMAX_spacingtype ()
	From given vertical grid zlevels[], determine `dzMIN`, `dzMAX`, `dzbMIN`, `dzbMAX` and determine whether ice and bedrock vertical spacings are equal.
PetscErrorCode	compute_fine_vertical_grid ()
	Computes fine vertical spacing in the ice and bedrock.
PetscErrorCode	init_interpolation ()

Detailed Description

Describes the PISM grid and the distribution of data across processors.

This class holds parameters describing the grid, including the vertical spacing and which part of the horizontal grid is owned by the processor. It contains the dimensions of the PISM (4-dimensional, x*y*z*time) computational box. The vertical spacing can be quite arbitrary.

It creates and destroys a two dimensional PETSc DA (distributed array). The creation of this DA is the point at which PISM gets distributed across multiple processors.

It computes grid parameters for the fine and equally-spaced vertical grid used in the conservation of energy and age equations.

Definition at line 42 of file grid.hh.

Constructor & Destructor Documentation

IceGrid	(	MPI_Comm	c,
		PetscMPIInt	r,
		PetscMPIInt	s,
		const NCConfigVariable &	config
	)

Definition at line 23 of file grid.cc.

References bed_fine2storage, bed_storage2fine, bed_vertical_spacing, com, compute_horizontal_spacing(), compute_vertical_levels(), da2, end_year, EQUAL, NCConfigVariable.get(), NCConfigVariable.get_string(), ice_fine2storage, ice_storage2fine, ice_vertical_spacing, initial_Mz, lambda, Lbz, Lx, Ly, Lz, Mbz, Mbz_fine, Mx, My, Mz, Mz_fine, NONE, Nx, Ny, periodicity, QUADRATIC, start_year, x0, X_PERIODIC, XY_PERIODIC, y0, Y_PERIODIC, year, zblevels, zblevels_fine, zlevels, and zlevels_fine.

~IceGrid ( )

Definition at line 108 of file grid.cc.

References bed_fine2storage, bed_storage2fine, da2, ice_fine2storage, ice_storage2fine, zblevels, zblevels_fine, zlevels, and zlevels_fine.

Member Function Documentation

PetscErrorCode compute_bed_vertical_levels ( )

Compute vertical levels in the bedrock.

PISM supports equal and quadratic spacing of bedrock levels.

Please see IceGrid.compute_ice_vertical_levels() for more.

Definition at line 209 of file grid.cc.

References bed_vertical_spacing, dzbMAX, dzbMIN, dzMIN, e, EQUAL, lambda, Lbz, Mbz, QUADRATIC, and zblevels.

Referenced by compute_vertical_levels().

PetscErrorCode compute_fine_vertical_grid ( ) [private]

Computes fine vertical spacing in the ice and bedrock.

The computations in IceModel.temperatureStep() and IceModel.ageStep() use a fine equally-spaced grid.

This method computes the number of levels and the levels themselves so that fine equally-spaced grids in ice and bedrock have the same spacing (if bedrock is present).

Mapping to and from the storage grid occurs in IceModelVec3 and IceModelVec3Bedrock methods.

Note that the computational grid in the ice is allowed to exceed Lz; we need this to match spacings (see above). The temperature field is extrapolated to the extra level using the value from the topmost level.

Definition at line 599 of file grid.cc.

References dz_fine, dzbMIN, dzMIN, e, init_interpolation(), Lbz, Lz, Mbz_fine, Mz_fine, zblevels_fine, and zlevels_fine.

Referenced by compute_vertical_levels(), and set_vertical_levels().

PetscErrorCode compute_horizontal_coordinates	(	double *&	x,
		double *&	y
	)

Computes values of x and y corresponding to the computational grid, with accounting for periodicity.

This method allocates arrays x and y, and they have to be freed (using delete[]) by the caller.

Definition at line 723 of file grid.cc.

References compute_horizontal_spacing(), dx, dy, Lx, Ly, Mx, My, periodicity, x0, X_PERIODIC, y0, and Y_PERIODIC.

Referenced by PISMIO.create_dimensions().

PetscErrorCode compute_horizontal_spacing ( )

Compute horizontal spacing parameters dx and dy using Mx, My, Lx, Ly and periodicity.

The grid used in PISM, in particular the PETSc DAs used here, are periodic in x and y. This means that the ghosted values foo[i+1][j], foo[i-1][j], foo[i][j+1], foo[i][j-1] for all 2D Vecs, and similarly in the x and y directions for 3D Vecs, are always available. That is, they are available even if i,j is a point at the edge of the grid. On the other hand, by default, dx is the full width 2 * Lx divided by Mx - 1. This means that we conceive of the computational domain as starting at the i = 0 grid location and ending at the i = Mx - 1 grid location, in particular. This idea is not quite compatible with the periodic nature of the grid.

The upshot is that if one computes in a truly periodic way then the gap between the i = 0 and i = Mx - 1 grid points should also have width dx. Thus we compute dx = 2 * Lx / Mx.

Definition at line 552 of file grid.cc.

References dx, dy, Lx, Ly, Mx, My, periodicity, X_PERIODIC, and Y_PERIODIC.

Referenced by compute_horizontal_coordinates(), PISMIO.get_grid(), IceGrid(), IceMISMIPModel.set_grid_from_options(), and IceModel.set_grid_from_options().

PetscErrorCode compute_ice_vertical_levels ( )

Set the vertical levels in the ice according to values in Mz, Lz, and the ice_vertical_spacing data member.

Sets dzMIN and dzMAX. Sets and re-allocates zlevels[].

Uses Mz, Lz, and ice_vertical_spacing. (Note that ice_vertical_spacing cannot be UNKNOWN.)

This procedure is only called when a grid is determined from scratch, e.g. by a derived class or when bootstrapping from 2D data only, but not when reading a model state input file (which will have its own grid, which may not even be a grid created by this routine).

When vertical_spacing == EQUAL, the vertical grid in the ice is equally spaced: zlevels[k] = k dzMIN where dzMIN = Lz / (Mz - 1). In this case dzMIN = dzMAX.
When vertical_spacing == QUADRATIC, the spacing is a quadratic function. The intent is that the spacing is smaller near the base than near the top. In particular, if $\zeta_k = k / (\mathtt{Mz} - 1)$ then zlevels[k] = Lz * ( ( / ) * (1.0 + ( - 1.0) ) ) where $\lambda$ = 4. The value $\lambda$ indicates the slope of the quadratic function as it leaves the base. Thus a value of $\lambda$ = 4 makes the spacing about four times finer at the base than equal spacing would be.

Definition at line 159 of file grid.cc.

References dzMAX, dzMIN, EQUAL, ice_vertical_spacing, lambda, Lz, Mz, QUADRATIC, and zlevels.

Referenced by compute_vertical_levels().

void compute_nprocs ( ) [private]

Definition at line 374 of file grid.cc.

References com, Mx, My, Nx, Ny, and size.

Referenced by createDA().

PetscErrorCode compute_vertical_levels ( )

Compute vertical levels in both ice and bedrock.

Definition at line 125 of file grid.cc.

References compute_bed_vertical_levels(), compute_fine_vertical_grid(), and compute_ice_vertical_levels().

Referenced by IceModel.bootstrapFromFile(), IceGrid(), IceMISMIPModel.set_grid_from_options(), and IceModel.set_grid_from_options().

PetscErrorCode createDA	(	PetscInt	procs_x,
		PetscInt	procs_y,
		PetscInt *&	lx,
		PetscInt *&	ly
	)

Definition at line 457 of file grid.cc.

References com, da2, Mx, My, size, verbPrintf(), xm, xs, ym, and ys.

PetscErrorCode createDA ( )

Create the PETSc DA da2 for the horizontal grid. Determine how the horizontal grid is divided among processors.

This procedure should only be called after the parameters describing the horizontal computational box (Lx,Ly) and the parameters for the horizontal grid (Mx,My) are already determined. In particular, the input file (either -i or -boot_from) and user options (like -Mx) must have already been read to determine the parameters, and any conflicts must have been resolved.

This method contains the "fundamental" transpose: "My,Mx" instead of "Mx,My" in the DACreate2d call; this transpose allows us to index arrays by "[i][j]" (where 'i' corresponds to 'x' and 'j' to 'y') and be consistent about meanings of 'x', 'y', 'u' and 'v'.

Unfortunately this means that PETSc viewers appear transposed.

This choice should be virtually invisible, unless you're using DALocalInfo structures.

See IceModelVec3 for creation of three-dimensional DAs.