Fluid cell

Name

Fluid cell -- 

Synopsis


#include <gfs.h>


#define     GFS_VARIABLE                    (cell, index)
#define     GFS_VELOCITY_COMPONENT          (index)
#define     GFS_VELOCITY_INDEX              (component)
#define     GFS_GRADIENT_COMPONENT          (index)
#define     GFS_GRADIENT_INDEX              (component)
#define     GFS_FACE_NORMAL_VELOCITY_RIGHT  (fa)
#define     GFS_FACE_NORMAL_VELOCITY_LEFT   (fa)
#define     GFS_FACE_NORMAL_VELOCITY        (fa)
#define     GFS_IS_SMALL                    (cell)
#define     GFS_CELL_IS_BOUNDARY            (cell)

struct      GfsStateVector;
struct      GfsFaceStateVector;
struct      GfsVariable;
enum        GfsPermanentVariable;
void        (*GfsVariableDerivedFunc)       (FttCell *cell,
                                             GfsVariable *v);
void        (*GfsVariableFineCoarseFunc)    (FttCell *cell,
                                             GfsVariable *v);
enum        GfsFlags;

void        gfs_cell_init                   (FttCell *cell);
void        gfs_cell_reset                  (FttCell *cell,
                                             GfsVariable *v);
void        gfs_cell_cleanup                (FttCell *cell);
void        gfs_cell_copy                   (const FttCell *from,
                                             FttCell *to);
GfsVariable* gfs_variable_new               (const gchar *name,
                                             guint i);
GfsVariable* gfs_variable_copy              (GfsVariable *v);
GfsVariable* gfs_variable_list_copy         (GfsVariable *v);
void        gfs_variable_list_destroy       (GfsVariable *v);
gdouble     gfs_variable_source             (GfsVariable *v,
                                             FttCell *cell);
GfsVariable* gfs_variable_from_name         (GfsVariable *variables,
                                             const gchar *name);
GfsVariable* gfs_variables_from_list        (GfsVariable *variables,
                                             gchar *list,
                                             gchar **error);
GtsRange    gfs_stats_variable              (FttCell *root,
                                             GfsVariable *v,
                                             FttTraverseFlags flags,
                                             gint max_depth);
GfsNorm     gfs_norm_variable               (FttCell *root,
                                             GfsVariable *v,
                                             FttTraverseFlags flags,
                                             gint max_depth);
void        gfs_variable_destroy            (GfsVariable *v);
void        gfs_get_from_below_intensive    (FttCell *cell,
                                             const GfsVariable *v);
void        gfs_get_from_below_extensive    (FttCell *cell,
                                             const GfsVariable *v);
void        gfs_get_from_above              (FttCell *cell,
                                             const GfsVariable *v);
void        gfs_cell_coarse_init            (FttCell *cell,
                                             GfsVariable *variables);
void        gfs_cell_fine_init              (FttCell *cell,
                                             GfsVariable *variables);
void        gfs_velocity_norm               (FttCell *cell,
                                             GfsVariable *v);
void        gfs_velocity_norm2              (FttCell *cell,
                                             GfsVariable *v);
void        gfs_divergence                  (FttCell *cell);
void        gfs_normal_divergence           (FttCell *cell);
void        gfs_vorticity                   (FttCell *cell,
                                             GfsVariable *v);
gdouble     gfs_face_interpolated_value     (const FttCellFace *face,
                                             guint v);
gdouble     gfs_interpolate                 (FttCell *cell,
                                             FttVector p,
                                             guint v);

struct      GfsGradient;
void        gfs_face_gradient               (const FttCellFace *face,
                                             GfsGradient *g,
                                             guint v,
                                             gint max_level);
void        gfs_face_weighted_gradient      (const FttCellFace *face,
                                             GfsGradient *g,
                                             guint v,
                                             gint max_level);
gdouble     (*GfsCenterGradient)            (FttCell *cell,
                                             FttComponent c,
                                             guint v);
gdouble     gfs_center_gradient             (FttCell *cell,
                                             FttComponent c,
                                             guint v);
gdouble     gfs_center_van_leer_gradient    (FttCell *cell,
                                             FttComponent c,
                                             guint v);

void        gfs_cell_write                  (const FttCell *cell,
                                             FILE *fp,
                                             GfsVariable *variables);
void        gfs_cell_read                   (FttCell *cell,
                                             GtsFile *fp,
                                             GfsVariable *variables);

Description

Details

GFS_VARIABLE()

#define GFS_VARIABLE(cell, index)     ((&GFS_STATE (cell)->div)[index])

Evaluates to the value of variable index in cell.

cell :a FttCell.
index :a GfsVariable.


GFS_VELOCITY_COMPONENT()

#define GFS_VELOCITY_COMPONENT(index) ((index) - GFS_U)

index : 


GFS_VELOCITY_INDEX()

#define GFS_VELOCITY_INDEX(component) (GFS_U + (component))

component : 


GFS_GRADIENT_COMPONENT()

#define GFS_GRADIENT_COMPONENT(index) ((index) - GFS_GX)

index : 


GFS_GRADIENT_INDEX()

#define GFS_GRADIENT_INDEX(component) (GFS_GX + (component))

component : 


GFS_FACE_NORMAL_VELOCITY_RIGHT()

#define     GFS_FACE_NORMAL_VELOCITY_RIGHT(fa)

fa : 


GFS_FACE_NORMAL_VELOCITY_LEFT()

#define     GFS_FACE_NORMAL_VELOCITY_LEFT(fa)

fa : 


GFS_FACE_NORMAL_VELOCITY()

#define     GFS_FACE_NORMAL_VELOCITY(fa)

fa : 


GFS_IS_SMALL()

#define     GFS_IS_SMALL(cell)

cell : 


GFS_CELL_IS_BOUNDARY()

#define GFS_CELL_IS_BOUNDARY(cell) (((cell)->flags & GFS_FLAG_BOUNDARY) != 0)

cell : 


struct GfsStateVector

struct GfsStateVector {
  /* temporary face variables */
  GfsFaceStateVector f[FTT_NEIGHBORS];

  /* solid boundaries */
  GfsSolidVector * solid;

  /* centered temporary variables */
  gdouble div, dp, res;
  gdouble g[FTT_DIMENSION];

  /* centered primitive variables */
  gdouble p;
  gdouble u, v;
#ifndef FTT_2D
  gdouble w;
#endif /* FTT_3D */
  gdouble c, ch;
};

The fluid variables describing the state of the cell.


struct GfsFaceStateVector

struct GfsFaceStateVector {
  gdouble un;
  gdouble v;
};


struct GfsVariable

struct GfsVariable {
  guint i;
  gchar * name;
  GfsVariableDerivedFunc derived;
  GfsVariableFineCoarseFunc fine_coarse;
  GtsContainer * sources;
  GfsVariable * next;
};

The fluid variables associated with a fluid cell.


enum GfsPermanentVariable

typedef enum {
  /* centered temporary variables */
  GFS_DIV = 0,
  GFS_DP,
  GFS_RES,
  GFS_GX,
  GFS_GY,
#ifndef FTT_2D
  GFS_GZ,
#endif /* FTT_3D */
  /* centered primitive variables */
  GFS_P,
  GFS_U, GFS_V,
#ifndef FTT_2D
  GFS_W,
#endif /* FTT_3D */
} GfsPermanentVariable;


GfsVariableDerivedFunc ()

void        (*GfsVariableDerivedFunc)       (FttCell *cell,
                                             GfsVariable *v);

cell : 
v : 


GfsVariableFineCoarseFunc ()

void        (*GfsVariableFineCoarseFunc)    (FttCell *cell,
                                             GfsVariable *v);

cell : 
v : 


enum GfsFlags

typedef enum {
  GFS_FLAG_USED =     1 <<  FTT_FLAG_USER,
  GFS_FLAG_BOUNDARY = 1 << (FTT_FLAG_USER + 1),
  GFS_FLAG_USER =           FTT_FLAG_USER + 2 /* user flags start here */
} GfsFlags;


gfs_cell_init ()

void        gfs_cell_init                   (FttCell *cell);

Allocates the memory for fluid state data associated to cell.

cell : a FttCell.


gfs_cell_reset ()

void        gfs_cell_reset                  (FttCell *cell,
                                             GfsVariable *v);

Sets the value of the variable v of cell to zero.

cell : a FttCell.
v : a GfsVariable to reset.


gfs_cell_cleanup ()

void        gfs_cell_cleanup                (FttCell *cell);

Frees the memory allocated for extra data associated with cell.

This function must be used as "cleanup function" when using ftt_cell_destroy().

cell : a FttCell.


gfs_cell_copy ()

void        gfs_cell_copy                   (const FttCell *from,
                                             FttCell *to);

Copies the attributes of the fluid cell from to the fluid cell to.

from : a FttCell to copy attributes from.
to : a FttCell to copy attributes to.


gfs_variable_new ()

GfsVariable* gfs_variable_new               (const gchar *name,
                                             guint i);

name : the name of the variable.
i : the variable index.
Returns : a newly allocated GfsVariable,


gfs_variable_copy ()

GfsVariable* gfs_variable_copy              (GfsVariable *v);

v : a GfsVariable.
Returns : a newly allocated copy of v.


gfs_variable_list_copy ()

GfsVariable* gfs_variable_list_copy         (GfsVariable *v);

v : a GfsVariable.
Returns : a new variable list copy of v.


gfs_variable_list_destroy ()

void        gfs_variable_list_destroy       (GfsVariable *v);

Free all the memory allocated for the list starting at v.

v : a GfsVariable.


gfs_variable_source ()

gdouble     gfs_variable_source             (GfsVariable *v,
                                             FttCell *cell);

v : a GfsVariable.
cell : a FttCell.
Returns : the sum of all the sources for variable v in cell.


gfs_variable_from_name ()

GfsVariable* gfs_variable_from_name         (GfsVariable *variables,
                                             const gchar *name);

variables : the list of available GfsVariable.
name : the name of the variable to find.
Returns : the GfsVariable name or NULL if this variable name does not exist.


gfs_variables_from_list ()

GfsVariable* gfs_variables_from_list        (GfsVariable *variables,
                                             gchar *list,
                                             gchar **error);

variables : the list of available GfsVariable.
list : a malloc'ed string containing comma separated variable names.
error : where to return the variable name in case of error.
Returns : a list of variables or NULL in case of error, in which case *error points to the name of the unknown variable.


gfs_stats_variable ()

GtsRange    gfs_stats_variable              (FttCell *root,
                                             GfsVariable *v,
                                             FttTraverseFlags flags,
                                             gint max_depth);

Traverses the cell tree defined by root using ftt_cell_traverse() and gathers statistics about variable v.

root : the root FttCell of the tree to obtain statistics from.
v : the variable to consider for statistics.
flags : which types of cells are to be visited.
max_depth : maximum depth of the traversal.
Returns : a GtsRange containing the statistics about v.


gfs_norm_variable ()

GfsNorm     gfs_norm_variable               (FttCell *root,
                                             GfsVariable *v,
                                             FttTraverseFlags flags,
                                             gint max_depth);

Traverses the cell tree defined by root using ftt_cell_traverse() and gathers norm statistics about variable v.

root : the root FttCell of the tree to obtain norm from.
v : the variable to consider for norm statistics.
flags : which types of cells are to be visited.
max_depth : maximum depth of the traversal.
Returns : a GfsNorm containing the norm statistics about v.


gfs_variable_destroy ()

void        gfs_variable_destroy            (GfsVariable *v);

Free all the memory allocated for v.

v : a GfsVariable.


gfs_get_from_below_intensive ()

void        gfs_get_from_below_intensive    (FttCell *cell,
                                             const GfsVariable *v);

Sets the value of the "intensive" variable v of cell by taking the volume weighted average of the values of its children cells.

This functions fails if cell is a leaf of the cell tree.

cell : a FttCell.
v : a GfsVariable to "get from below".


gfs_get_from_below_extensive ()

void        gfs_get_from_below_extensive    (FttCell *cell,
                                             const GfsVariable *v);

Sets the value of the "extensive" variable v of cell as (half in 3D) the sum of the values of its children cells.

This functions fails if cell is a leaf of the cell tree.

cell : a FttCell.
v : a GfsVariable to "get from below".


gfs_get_from_above ()

void        gfs_get_from_above              (FttCell *cell,
                                             const GfsVariable *v);

Sets the value of the variable v of cell to the value of this variable in its parent cell.

This function fails if cell is the root of the cell tree.

cell : a FttCell.
v : a GfsVariable to "get from above".


gfs_cell_coarse_init ()

void        gfs_cell_coarse_init            (FttCell *cell,
                                             GfsVariable *variables);

Initialises the variables of cell using the values of its children cells.

cell : a FttCell.
variables : a list of GfsVariable.


gfs_cell_fine_init ()

void        gfs_cell_fine_init              (FttCell *cell,
                                             GfsVariable *variables);

Initializes the variables of cell using interpolation from its parent cell.

First-order interpolation (straight injection) is used for boundary cells and second-order interpolation for the other cells.

cell : a FttCell.
variables : a list of GfsVariable.


gfs_velocity_norm ()

void        gfs_velocity_norm               (FttCell *cell,
                                             GfsVariable *v);

Fills variable v of cell with the norm of the velocity field in this cell.

cell : a FttCell.
v : a GfsVariable.


gfs_velocity_norm2 ()

void        gfs_velocity_norm2              (FttCell *cell,
                                             GfsVariable *v);

Fills variable v of cell with the sqaured norm of the velocity field in this cell.

cell : a FttCell.
v : a GfsVariable.


gfs_divergence ()

void        gfs_divergence                  (FttCell *cell);

Fills variable GFS_DIV of cell with the divergence of the (centered) velocity field in this cell.

cell : a FttCell.


gfs_normal_divergence ()

void        gfs_normal_divergence           (FttCell *cell);

Fills variable GFS_DIV of cell with the integral of the divergence of the (MAC) velocity field in this cell.

cell : a FttCell.


gfs_vorticity ()

void        gfs_vorticity                   (FttCell *cell,
                                             GfsVariable *v);

Fills variable v of cell with the vorticity (norm of the vorticity vector in 3D) of the velocity field in this cell.

cell : a FttCell.
v : a GfsVariable.


gfs_face_interpolated_value ()

gdouble     gfs_face_interpolated_value     (const FttCellFace *face,
                                             guint v);

Computes the value of variable v on the face using second-order interpolation from the cell-centered values.

face : a FttFace.
v : a GfsVariable index.
Returns : the value of variable v on the face.


gfs_interpolate ()

gdouble     gfs_interpolate                 (FttCell *cell,
                                             FttVector p,
                                             guint v);

Interpolates the v variable of cell, at location p. Linear interpolation is used and the boundaries of the domain are treated as planes of symmetry for all variables.

Note that to work correctly this function needs a domain where the values of variable v are defined on all levels.

cell : a FttCell containing location p.
p : the location at which to interpolate.
v : a GfsVariable index.
Returns : the interpolated value of variable v at location p.


struct GfsGradient

struct GfsGradient {
  gdouble a, b;
};

Defines the (second-order accurate) gradient of a variable v in a given direction as: a*GFS_VARIABLE (cell, v) + b.


gfs_face_gradient ()

void        gfs_face_gradient               (const FttCellFace *face,
                                             GfsGradient *g,
                                             guint v,
                                             gint max_level);

Set the value of g as the gradient of variable v on the face. The value returned is second order accurate in space and conservative, in the sense that values at a coarse/fine cell boundary are consistent.

face : a FttCellFace.
g : the GfsGradient.
v : a GfsVariable index.
max_level : the maximum cell level to consider (-1 means no restriction).


gfs_face_weighted_gradient ()

void        gfs_face_weighted_gradient      (const FttCellFace *face,
                                             GfsGradient *g,
                                             guint v,
                                             gint max_level);

Set the value of g as the gradient of variable v on the face weighted by the value of v field of the face state vector of the corresponding cell. The value returned is second order accurate in space and conservative, in the sense that values at a coarse/fine cell boundary are consistent.

face : a FttCellFace.
g : the GfsGradient.
v : a GfsVariable index.
max_level : the maximum cell level to consider (-1 means no restriction).


GfsCenterGradient ()

gdouble     (*GfsCenterGradient)            (FttCell *cell,
                                             FttComponent c,
                                             guint v);

cell : 
c : 
v : 
Returns : 


gfs_center_gradient ()

gdouble     gfs_center_gradient             (FttCell *cell,
                                             FttComponent c,
                                             guint v);

The gradient is normalized by the size of the cell.

cell : a FttCell.
c : a component.
v : a GfsVariable index.
Returns : the value of the c component of the gradient of variable v at the center of the cell.


gfs_center_van_leer_gradient ()

gdouble     gfs_center_van_leer_gradient    (FttCell *cell,
                                             FttComponent c,
                                             guint v);

The gradient is normalized by the size of the cell and is limited using van Leer's limiter.

cell : a FttCell.
c : a component.
v : a GfsVariable index.
Returns : the value of the c component of the gradient of variable v at the center of the cell.


gfs_cell_write ()

void        gfs_cell_write                  (const FttCell *cell,
                                             FILE *fp,
                                             GfsVariable *variables);

Writes in fp the fluid data associated with cell and described by variables. This function is generally used in association with ftt_cell_write().

cell : a FttCell.
fp : a file pointer.
variables : the GfsVariable to be written.


gfs_cell_read ()

void        gfs_cell_read                   (FttCell *cell,
                                             GtsFile *fp,
                                             GfsVariable *variables);

Reads from fp the fluid data associated with cell and described by variables. This function is generally used in association with ftt_cell_read().

cell : a FttCell.
fp : a GtsFile.
variables : the GfsVariable to be read.