e_block.h

Go to the documentation of this file.

#ifndef E_BLOCK_HEADER_ALREADY_INCLUDED

#include <stdio.h>
#include "../../util/source/useful.h"
#include "../../geometry/source/geom.h"
#include "../../gas_models/source/gas.h"
#include "../../flux_calc/source/flux_calc.h"
#include "../../mb_cns/source/cns_cell.h"

#define NGHOST 2

#define BLOCK_3D_DIM 200

#define MAX_FLOW_CONDITION 20

/*----------------------------------------------------------------*/

struct block_data_3D
{
    int id;                     /* block identifier           */
    /* id will usually be the same as the block number.       */
    char label[132];            /* symbolic name              */
    char root_file_name[132];              /* root of file names for block data  */
    FILE *hfp;                             /* history file handle                */
    int  create_mesh_from_edges;           /* 0: read from file; 1: generate new */

    double dt_global;           /* global time step, s        */
    double dt_allow;            /* Allowable time step        */
    double cfl_target;          /* desired CFL number         */
    double sim_time;            /* simulation time in seconds */
    double cfl_min, cfl_max;    /* estimates of CFL number    */
    double cfl_tiny, time_tiny; /* the smallest so far...     */
    double residual;            /* residual monitor for       */
                                /* steady state               */
    int hncell;                 /* number of sample cells     */
    int hicell[NDIM], hjcell[NDIM], hkcell[NDIM]; /* location of sample cell */

    /* Total number of cells in each direction for this block.
     * these will be used in the array allocation routines.
     */
    int nidim, njdim, nkdim;
    /* Number of active cells in the i,j,k-directions */
    int nni, nnj, nnk;
    /* The following  index limits are set to allow convenient access 
     * to the arrays without having to worry how many buffer 
     * cells are present.
     * imin <= i <= imax,  jmin <= j <= jmax
     * Typically imin = jmin = kmin = 2.
     */
    int imin, imax, jmin, jmax, kmin, kmax;

    /* Most of the data is stored in the following arrays.
     * ctr[i][j][k]: primary-cell centers
     * ifi[i][j][k], ifj[i][j][k], ifk[i][j][k] cell-interfaces
     * vtx[i][j][k]: primary-cell vertices
     *
     * cell-interfaces are used to interface to the Riemann solver
     * and to store the interface fluxes.
     *
     * vtx is used for the viscous terms.
     * Primary-cell vertices are secondary-cell centres.
     * sifi, sifj and sifk are secondary-cell interfaces
     */
    struct cell_center    ***ctr;
    struct cell_interface ***ifi;
    struct cell_interface ***ifj;
    struct cell_interface ***ifk;
    struct cell_vertex    ***vtx;
    struct cell_interface ***sifi;
    struct cell_interface ***sifj;
    struct cell_interface ***sifk;

    /* Boundary condition flags for the block-domain boundaries. */
    int bc[6];
    /* Fill and inflow gas properties are recorded here. */
    struct flow_state flow_condition[MAX_FLOW_CONDITION]; 
    int n_flow_condition;
    /* Index to the relevant gas_state. */
    int initial_fill_condition;
    int inflow_condition[6]; 
    /* Wall temperatures for use with the FIXED_T boundary condition. */
    double Twall[6];
    /* Flags to indicate whether the sponge layer is active for
     * Andrew Denman's subsonic boundary condition. */
    int sponge[6];
    /* Fixed-pressure outflow. */
    double Pout[6];

    /* 
     * Neighbour information.
     * It should be enough to know which blocks are adjacent to any
     * particular face and then to know which of the neighbour's 
     * corner vertices correspond to the current-block's vertices.
     */
    /* Identities of the neighbouring blocks (-1 == None) at each face. */
    int neighbour_block[6];
    int neighbour_faceId[6];
    int neighbour_orientation[6];
    /* Corresponding vertex on the neighbour's adjacent face. 
     * The following storage is a bit of over-kill but it allows us
     * to separate the sorting out of connections from the reading
     * of the parameter file. */
    int neighbour_vertex[6][8];

    /* Transfinite interpolation can be used to make the grid from
     * the 12 edges of the block. Save polyline pointers and chuster_tuple. */
    struct GPathPolyLine *edge[12];
    int end0[12], end1[12];
    double beta[12];
    /* Block vertex locations can be used to create a simple grid. */
    struct Vector3D corner_vertex[8];

    /* Flag to indicate if cgns grid has been written for a block */
    int cgns_grid_written;

    /* Flag to indicate if filtering coefficients have been calculated */
    int dev_filter_coefficients;

    /* Buffers for boundary-data exchange. */
    double *send_buffer[6];
    double *receive_buffer[6];

};  /* end of block_data_3D structure definition */


int set_neighbour_blockId_for_face(struct block_data_3D * this_blk,
                                   int face_index,
                                   int other_blockId);
int get_neighbour_blockId_for_face(struct block_data_3D * this_blk,
                                   int face_index);
int set_neighbour_vertex(struct block_data_3D * this_blk,
                         int face_index,
                         int vertex_index,
                         int other_vertex);
int get_neighbour_vertex(struct block_data_3D * this_blk,
                         int face_index,
                         int vertex_index);
int set_corner_vertex_location(struct block_data_3D * this_blk,
                               int vertex_index, 
                               double x, double y, double z);
int set_edge_polyline(struct block_data_3D * this_blk,
                      int edge_index, 
                      struct GPathPolyLine *plp,
                      int end0, int end1, double beta);

int set_bc_index_for_boundary(struct block_data_3D * this_blk,
                              int ibndy, int value);
int get_bc_index_for_boundary(struct block_data_3D * this_blk,
                              int ibndy);
int set_inflow_index_for_boundary(struct block_data_3D * this_blk,
                                  int ibndy, int value);
int set_sponge_flag_for_boundary(struct block_data_3D * this_blk,
                                 int ibndy, int value);
double set_Twall_for_boundary(struct block_data_3D * this_blk,
                              int ibndy, double value);

struct cell_center * get_cell_center_ptr(struct block_data_3D * this_blk,
                                         int i, int j, int k);
struct cell_interface * get_ifi_ptr(struct block_data_3D * this_blk,
                                    int i, int j, int k);
struct cell_interface * get_ifj_ptr(struct block_data_3D * this_blk,
                                    int i, int j, int k);
struct cell_interface * get_ifk_ptr(struct block_data_3D * this_blk,
                                    int i, int j, int k);

int array_alloc_3D(struct block_data_3D *A);
int allocate_send_and_receive_buffers_3D( struct block_data_3D *bp );

int fill_block_flow_data_3D(struct block_data_3D *bp);
int compute_block_geometry_data_3D(struct block_data_3D *bp);
int add_history_cell_to_block(struct block_data_3D *bp, int i, int j, int k);

/* Vertices -- VTK convention for a hexahedral cell. */
#define IVTX0 (i)
#define JVTX0 (j)
#define KVTX0 (k)

#define IVTX1 (i+1)
#define JVTX1 (j)
#define KVTX1 (k)

#define IVTX2 (i+1)
#define JVTX2 (j+1)
#define KVTX2 (k)

#define IVTX3 (i)
#define JVTX3 (j+1)
#define KVTX3 (k)

#define IVTX4 (i)
#define JVTX4 (j)
#define KVTX4 (k+1)

#define IVTX5 (i+1)
#define JVTX5 (j)
#define KVTX5 (k+1)

#define IVTX6 (i+1)
#define JVTX6 (j+1)
#define KVTX6 (k+1)

#define IVTX7 (i)
#define JVTX7 (j+1)
#define KVTX7 (k+1)

/* Vertices -- Ian Johnstons labels -- try to use VTK labelling. */
#define IA (i)
#define JA (j)
#define KA (k+1)

#define IB (i+1)
#define JB (j)
#define KB (k+1)

#define IC (i+1)
#define JC (j)
#define KC (k)

#define ID (i)
#define JD (j)
#define KD (k)

#define IE (i)
#define JE (j+1)
#define KE (k+1)

#define IF (i+1)
#define JF (j+1)
#define KF (k+1)

#define IG (i+1)
#define JG (j+1)
#define KG (k)

#define IH (i)
#define JH (j+1)
#define KH (k)

#define IFACE_NORTH  (ifj[i][j+1][k])
#define IFACE_SOUTH  (ifj[i][j][k])
#define IFACE_EAST   (ifi[i+1][j][k])
#define IFACE_WEST   (ifi[i][j][k])
#define IFACE_TOP    (ifk[i][j][k+1])
#define IFACE_BOTTOM (ifk[i][j][k])


#define NORTH   4
#define EAST    3
#define SOUTH   0
#define WEST    2
#define TOP     5
#define BOTTOM  1



/*-------------------------------------------------------------------*/

#define E_BLOCK_HEADER_ALREADY_INCLUDED
#endif

---