# Values, macros and structures in Gerris

### From Gerris

## Values defined in Gerris

N_CELLS = FTT_CELLS = <math>2^{dimension}</math>

FTT_NEIGHBORS_2D = (FTT_BOTTOM) + 1

GFS_STATUS_UNDEFINED = 0

GFS_STATUS_SOLID = 1

GFS_STATUS_FLUID = 2

## Gerris Macros

## Gerris structures

### CellCube

typedef struct {

GtsPoint p[8];

GfsSegment s[12];

}

The vertices of the cube are stored in the GtsPoint array and the edges in the GfsSegment array.

### CellFace

typedef struct {

GtsPoint p[4];

GfsSegment s[4];

}

The vertices of the face are stored in the GtsPoint array and the edges in the GfsSegment array.

### CompatPar

typedef struct {

GfsVariable * lhs;

gboolean dirichlet;

}

The homogeneous version of the considered GfsVariable is stored in *lhs*.

### DiffusionCoeff

typedef struct {

GfsSourceDiffusion * d;

gdouble lambda2[FTT_DIMENSION];

gdouble dt;

GfsVariable * rhoc, * metric;

GfsFunction * alpha;

GfsDomain * domain;

}

*d* is a GfsSourceDiffusion, *dt* is the timestep, the GfsVariable *rhoc* is the mass, *metric* is the implicit metric term, the GfsFunction *alpha* is the inverse of the density and *domain* is the considered GfsDomain.

### FttCell

struct {

/*<public>*/

guint flags;

gpointer data;

/*<private>*/

struct _FttOct * parent, * children;

}

*children* and *parent* are the two FttOcts associated with the FttCell.

### FttCellChildren

struct {

FttCell * c[FTT_CELLS];

};

The children of the considered FttCell are stored in *c* (4 in 2D and 8 in 3D).

### FttCellFace

See FttCellFace.

### FttCellFlags

typedef enum {

FTT_FLAG_ID = 7,

FTT_FLAG_DESTROYED = 1 << 3,

FTT_FLAG_LEAF = 1 << 4, /* used only for I/O operations */

FTT_FLAG_TRAVERSED = FTT_FLAG_LEAF, /* used for face traversal */

FTT_FLAG_USER = 5 /* user flags start here */

}

### FttCellNeighbors

struct {

/* right, left, top, bottom, front, back */

FttCell * c[FTT_NEIGHBORS];

}

*c* is the array containing the neighbors of a considered FttCell.

### FttCellTraverse

struct {

FttCell ** cells;

FttCell ** curent;

}

### FttComponent

typedef enum

{

FTT_X = 0,

FTT_Y,

#if (!FTT_2D)

FTT_Z,

#endif /* FTT_3D */

FTT_DIMENSION,

FTT_XY,

#if FTT_2D

FTT_XYZ = FTT_XY

#else /* FTT_3D */

FTT_XYZ

#endif /* FTT_3D */

}

### FttDirection

See FttDirection.

### FttFaceType

typedef enum {

FTT_BOUNDARY,

FTT_FINE_FINE,

FTT_FINE_COARSE

}

### FttOct

struct {

guint level;

FttCell * parent;

FttCellNeighbors neighbors;

FttVector pos;

FttCell cells[FTT_CELLS];

}

*parent* is the FttCell to which the FttOct is linked, *level* its level (0 for the root, 1 for the children of the root, and so on).

The FttCellNeighbors *neighbors* stores the neighbors of *parent* and the FttVector *pos* gives the coordinates of the center of *parent*. The array *cells* contains the children of *parent*.

### FttRootCell

struct{

FttCell cell;

FttCellNeighbors neighbors;

FttVector pos;

guint level;

gpointer parent;

}

The FttCellNeighbors *neighbors* stores the neighbors of the FttCell *cell* (which should be FttRootCells too).

The FttVector *pos* gives the coordinates of the center of *cell* and *level* is the level of *cell* (the size of *cell* is <math>2^{level}</math>).

### FttTraverseType

typedef enum {

FTT_PRE_ORDER,

FTT_POST_ORDER

}

When the type *FTT_PRE_ORDER* is used, the traversed FttCell is considered before its FttCellChildren (and all functions are applied in this order). It happens the other way when the type *FTT_POST_ORDER* is used.

### FttVector

struct {

gdouble x, y, z;

}

FttVector defines a vector of coordinates *x*, *y*, and *z*.

### GfsBc

struct {

/*< private >*/

GtsObject parent;

GfsLinearProblem * lp;

/*< public >*/

GfsBoundary * b;

GfsVariable * v;

gboolean extra;

FttFaceTraverseFunc bc, homogeneous_bc;

FttFaceTraverseFunc homogeneous_bc_stencil;

FttFaceTraverseFunc face_bc;

}

The GfsLinearProblem *lp* is the linear problem being solved by Gerris.

The boundary which is concerned by the given condition is stored in the GfsBoundary *b*.

The boundary condition is applied to the GfsVariable *v*.

*bc*, *homogeneous_bc*, *homogeneous_bc_stencil* and *face_bc* are the functions to call when traversing the tree.

GfsBc is used to define a **default symmetry boundary condition**.

### GfsBoundary

struct {

/*< private >*/

GtsObject parent;

FttCell * root;

GfsBox * box;

FttDirection d;

guint depth;

GfsBc * default_bc;

gboolean changed;

/*< public >*/

GfsVariable * v;

GfsBoundaryVariableType type;

GHashTable * bc;

}

The boundary defined by this GfsBoundary structure is the one associated with the FttCellFace in FttDirection *d* of FttCell *root*.

*default_bc* is the default symmetry boundary condition (see GfsBc) and *box* the GfsBox associated with *root*.

The boundary condition is applied to the GfsVariable *v*.

GfsBoundary is used to define **one of the boundaries of a GfsBox**.

### GfsBoundaryPeriodic

struct {

/*> private >*/

GfsBoundary parent;

GfsBox * matching;

FttDirection d;

GArray * sndbuf, * rcvbuf;

guint sndcount, rcvcount;

gdouble rotate;

}

*parent* is the GfsBoundary concerned by the periodic condition.

This boundary is associated with the GfsBox *matching* in FttDirection *d*.

### GfsBox

struct {

GtsGNode parent;

FttCell * root;

GtsObject * neighbor[FTT_NEIGHBORS];

guint id;

int pid;

gint size;

}