structs.h

Go to the documentation of this file.

#include "define.h"
 
#ifndef s_mesh_
#define s_mesh_
 
#define STR_SIZE 1024
 
typedef struct t_message_ t_message;
 
typedef struct t_parameters_ t_parameters;
typedef struct t_mesh_ t_mesh;
 
typedef struct t_c_cell_ t_c_cell;
typedef struct l_c_cells_ l_c_cells;
 
typedef struct t_g_cell_ t_g_cell;
typedef struct l_g_cells_ l_g_cells;
 
typedef struct t_node_ t_node;
typedef struct l_nodes_ l_nodes;
 
typedef struct t_wall_ t_wall;
typedef struct l_wall_ l_wall;
 
typedef struct t_edge_ t_edge;
typedef struct l_edges_ l_edges;
 
typedef struct t_bound_ t_bound;
 
typedef struct t_solute_ t_solute;
typedef struct l_solutes_ l_solutes;
 
typedef struct t_arrays_ t_arrays;
typedef struct t_cuPtr_ t_cuPtr;
 
typedef struct t_timers_ t_timers;
 
struct t_message_{
    char logFile[1024]; 
    int error; 
    char errorProperty[1024]; 
    int nWarning;
    char **warning;
    int nMsgL0;
    char **MsgL0;
    int nMsgL1;
    char **MsgL1;
    int nMsgL2;
    char **MsgL2;
    int nMsgL3;
    char **MsgL3;
};
 
 
struct t_parameters_{
    char proj[1024];
    char dir[1024];
    int ncores, gpuid;
    double ti,tf,CFL;
 
    int writeMass;
    int writeExtremes;
    int indexWriteHotstart;
 
    int nIterOut;
    double dtOut;
    double dtDump;
    double minh;
 
};
 
 
struct t_mesh_{
    int id;
    int NCwall;
    int nnodes;
    int ncells;
    int ncellsBound;
    int nw_calc;
    int nw_bound;
 
    //mesh structure
    l_c_cells *c_cells;
    l_g_cells *g_cells;
    l_nodes *nodes;
 
    l_wall *w_bound;
    l_wall *w_calc;
    
    l_c_cells *b_cells; // Only the boundary Cells
 
    int nInlet;
    int nTotalCellsIn;
    t_bound *in;
    int nOutlet;
    int nTotalCellsOut;
    t_bound *out;
 
    double minZ, maxZ;
 
    //solutes
    int nSolutes;
    l_solutes *solutes;
 
};
 
 
struct t_c_cell_{
    int id;
    double z;
    double h;
    double hu;
    double hv;
    double u;
    double v;
    double modulou;
 
    double hini;
    double zini;
 
    double nMan;
 
    t_g_cell *geom;
 
    //Advection-Diffusion Transport 
    double *hphi;
    double *phi;
};
 
 
struct l_c_cells_{
    int size;
    int n;
    t_c_cell* cells;
    t_c_cell** pcells;
};
 
 
struct t_g_cell_{
    int id;
    int isBound;    // type cell identifier 
                    // 0 = inner cell
                    // 99 = closed boundary cell
                    // negative = inlet cell (- ID inlet)
                    // positive = outlet cell (+ ID outlet)
    double area;
    double center[3];
    int nneig; //número de vecinas, descontando los contornos
    int nbound; //número de contornos
    t_node *nodes[4];
    t_c_cell *neigcell[4];
    t_wall *neigwall[4];
    t_edge *wall;
    double Lwallmax;
};
 
 
struct l_g_cells_{
    int size;
    int n;
    t_g_cell *cells;
};
 
 
struct t_node_{
    int id;
    double x,y,z;
};
 
 
struct l_nodes_{
    int size;
    int n;
    double xmin,ymin,xmax,ymax;
    t_node *nodes;
};
 
 
struct t_wall_{
    int idWall;
 
    int node1;
    int node2;
    // This value represents, for c1, the identifier {0,1,2,{3}} of the wall
    // in order to select where to write at dh,dhu,dhv of the cell
    int i;
    // The same for c2
    int j;
 
    int id; // Identificador de la celda i
    int id2;// Identificaador de la celda j
    double lwall;
    double normal[2];
    double deltaX;
    double distNormal;//length between the centers of the cells
    double length;//length of the edge of each cell  
    double distCenter;
    double ncx, ncy;  
   
    // Punteros a las celdas i,j (0,1) de la pared
    t_c_cell *ccells[2];
    t_g_cell *gcells[2];
 
    int idBound; 
    int typeOfBound;    //type wall identifier
                        //-1 = inner wall
                        // 0 = closed bound wall
                        // 2 = inlet bound wall
                        // 3 = outlet bound wall
};
 
 
struct l_wall_{
    int size;
    int n;
    t_wall *wall;
};
 
 
struct t_edge_{
    int id;
    double normal[3];
    //t_c_cell *cells[2];
    double length;
    int isBoundary;
};
 
 
struct l_edges_{
    int size;
    int n;
    t_edge *walls;
};
 
 
struct t_bound_{
    char idname[1024];
    int type;               
    int n;                  
    int ncellsBound;        
    int ncellsInner;        
    t_c_cell *cellzMin;     
    t_wall **wallBound;     
    t_c_cell **cellBound;   
    t_c_cell **cellInner;   
    double *t;
    double *q;
    double *hZ;
    double *Fr;
    double **phi;
    double maxFroude;
    double totalLength;     
    double totalArea;       
    double zmin;            
    double levelControl;    
    int flagInitialize;    
    double qMass,qDischarge; //qMass is the mass of water that enters/leaves in form of water depth and qDischarge in form of discharge. The sum of this two quantities (times dt) represents the water volume that enters/leaves the boundary
    t_node node[2],normal;
    // *(n1)-------------*
    // |             |
    // |             |
    // *-------------(n2)*
    int iAct;   // Nos dice el indice, en la tabla de tiempos, correspondiente al tiempo actual
    double qliquid;
    double qsolid;
};
 
 
struct t_solute_{
    char name[STR_SIZE]; 
    int typeDiff; 
    double k_xx,k_yy; 
    double maxConc;
};
 
 
struct l_solutes_{
    int n;
    int flagDiffussion; //flag to determine if it is necessary to go inside diffusion subroutines
    t_solute *solute;
};
 
 
 
struct t_arrays_{
 
    //parameters
    int ncores; 
    int gpuid; 
    double ti; 
    double tf; 
    double CFL; 
    int writeMass; 
    int writeExtremes; 
    int indexWriteHotstart; 
    int nIterOut; 
    double dtOut; 
    double dtDump; 
    double minh; 
    int NCwall; 
    int ncells; 
    int nw_calc; 
    int nw_bound; 
    int nInlet; 
    int nOutlet; 
    //computation controls
    double t; 
    double dt; 
    int nIter; 
    int indexOut; 
    int indexDump; 
    int dumpComponent; 
    int dumpState; 
    double massOld; 
    double massNew; 
    double massError; 
    double massIn; 
    double massOut; 
    double qTotalIn; 
    double qTotalOut; 
    //solute controls
    int nSolutes; 
    //ARRAY DE CELDA
    int nActCells; 
    int *actCells; 
    int *activeC; 
    int *cidx; 
    int *nneig; 
    double *z; 
    double *h; 
    double *hu; 
    double *hv; 
    double *u; 
    double *v; 
    double *modulou; 
    double *sqrh; 
    double *area; 
    double *nman; 
    double *SOX; 
    double *SOY; 
    double *mass; 
    //ARRAY DE CELDAS*NPAREDES
    int nWallCell;
    double *dh; 
    double *dhu;
    double *dhv;
    int *solidWallByCell; 
    int *neighCell; 
    int *neighWall; 
    double *normalXbyCell; 
    double *normalYbyCell; 
    //ARRAY DE PAREDES INTERNAS DE CALCULO
    int nActWalls; 
    int *actWalls; 
    int *activeW; 
    int *widx; 
    int *idx1; 
    int *idx2; 
    int *idw1; 
    int *idw2; 
    double *normalX; 
    double *normalY; 
    double *deltaX; 
    double *length; 
    double *distNormal; 
    double *distCentX;  
    double *distCentY; 
    double *nman2wall; 
    double *gp; 
    int *typeOfBound; 
    int *solidWall; 
    double *qnormalL; 
    double *localDt; 
    // BOUNDARY ARRAYS ///////////////////////////  
    double *normalXIn, *normalYlIn;
    double *normalXOut, *normalYOut;    
 
    int nTotalCellsIn;  
    int *cidxIn;
    int *idBoundIn; 
    double *lengthwallIn;
 
    int nTotalCellsOut; 
    int *cidxOut;
    int *idBoundOut;
    double *lengthwallOut;      
 
 
    // SOLUTE ARRAYS ///////////////////////////    
    #if SET_SOLUTE
        int flagDiffusion; 
        //solute data
        int *typeDiff; //nsol
        double *k_xx, *k_yy; //nsol 
 
        //solute conservative
        double *hcsol; 
        double *csol; 
        //solute contributions
        double *dhcsol;
    #endif
 
};
 
 
struct t_cuPtr_{
 
    int *index, *check;
 
    double *t, *dt;
 
    int *nActCells, *nActWalls;
 
    int *nIter, *indexOut, *indexDump;
    int *dumpComponent, *dumpState;
 
    double *massOld, *massNew;
    double *massError;
 
    double *qTotalIn, *qTotalOut;   
 
    // GPU COMPUTATION ARRAYS ////////////////////////////////////////////
    //cells
    int *cidx, *nneig;
    int *activeC, *actCells;
    double *z, *h, *hu, *hv, *u, *v, *modulou, *sqrh;
    double *area, *nman, *SOX, *SOY;
    double *mass;
 
    //cells*NCwall
    double *dh, *dhu, *dhv;
    int *solidWallByCell, *neighCell, *neighWall;
    double *normalXbyCell, *normalYbyCell;
 
    //internal walls
    int *activeW, *actWalls;
    int *widx;
    int *idx1, *idx2, *idw1, *idw2;
    double *normalX, *normalY, *deltaX, *length, *distNormal, *distCentX, *distCentY;
    double *nman2wall, *gp;
    int *typeOfBound, *solidWall;
    double *qnormalL, *localDt;
 
 
    // BOUNDARY ARRAYS ///////////////////////////  
    int *cidxIn;
    int *idBoundIn; 
    double *normalXwallIn, *normalYwallIn;
    double *lengthwallIn;
 
    int *cidxOut;
    int *idBoundOut;
    double *normalXwallOut, *normalYwallOut;
    double *lengthwallOut;      
 
 
    // SOLUTE ARRAYS ///////////////////////////
    #if SET_SOLUTE
        //solutes
        int *typeDiff;
        double *k_xx, *k_yy; 
 
        //nsolutes*cells
        double *hcsol, *csol;
 
        //nsolutes*cells*NCwall
        double *dhcsol; 
    #endif
 
};
 
 
struct t_timers_{
    double total=0.0;
    double loading=0.0;
    double init=0.0;
    double initGPU=0.0;
    double computeSim=0.0;
    double wallCalculus=0.0;
    double cellUpdating=0.0;
    double boundConditon=0.0;
    double wetDryFix=0.0;
    double memoryTransfer=0.0;
    double writeOut=0.0;
};
 
 
#endif