blusgs.c

Go to the documentation of this file.

 
#include "blusgs.h"
#include "flux.h"
#include "inverse.h"
#include <stdio.h>
 
 
void ns_serial_pre_blusgs(UCFD_INT neles, UCFD_INT nface, UCFD_FLOAT factor,
                          UCFD_FLOAT *fnorm_vol, UCFD_FLOAT *dt, UCFD_FLOAT *diag, UCFD_FLOAT *fjmat)
{
    UCFD_INT idx, jdx, kdx, row, col;
    UCFD_FLOAT fv, dti;
    UCFD_FLOAT dmat[NFVARS][NFVARS];
 
    for (idx=0; idx<neles; idx++) {
        // Initialize diagonal matrix
        for (row=0; row<NFVARS; row++) {
            for (col=0; col<NFVARS; col++)
                dmat[row][col] = 0.0;
        }
        
        // Computes diagonal matrix based on neighbor cells
        for (jdx=0; jdx<nface; jdx++) {
            fv = fnorm_vol[neles*jdx + idx];
            for (row=0; row<NFVARS; row++) {
                for (col=0; col<NFVARS; col++) {
                    dmat[row][col] \
                        += fjmat[idx+neles*jdx+nface*neles*col+NFVARS*nface*neles*row]*fv;
                }
            }
        }
 
        // Complete implicit operator
        dti = 1.0/(dt[idx]*factor);
        for (kdx=0; kdx<NFVARS; kdx++) {
            dmat[kdx][kdx] += dti;
        }
        
        // LU decomposition for inverse process
        ludcmp(NFVARS, dmat);
 
        // Allocate temporal matrix to diag array
        for (row=0; row<NFVARS; row++) {
            for (col=0; col<NFVARS; col++) {
                diag[idx+neles*col+neles*NFVARS*row] = dmat[row][col];
            }
        }
    }
}
 
 
void rans_serial_pre_blusgs(UCFD_INT neles, UCFD_INT nface, UCFD_FLOAT factor,
                            UCFD_FLOAT *fnorm_vol, UCFD_FLOAT *uptsb, UCFD_FLOAT *dt,
                            UCFD_FLOAT *tdiag, UCFD_FLOAT *tjmat, UCFD_FLOAT *dsrc)
{
    UCFD_INT idx, jdx, kdx, row, col;
    UCFD_FLOAT fv;
    UCFD_FLOAT tmat[NTURBVARS][NTURBVARS];
    UCFD_FLOAT uf[NVARS], dsrcf[NVARS];
 
    for (idx=0; idx<neles; idx++) {
        // Initialize diagonal matrix
        for (row=0; row<NTURBVARS; row++) {
            for (col=0; col<NTURBVARS; col++)
                tmat[row][col] = 0.0;
        }
        
        for (kdx=0; kdx<NVARS; kdx++) {
            uf[kdx] = uptsb[idx+neles*kdx];
            dsrcf[kdx] = dsrc[idx+neles*kdx];
        }
        
        // Computes diagonal matrix based on neighbor cells
        for (jdx=0; jdx<nface; jdx++) {
            fv = fnorm_vol[neles*jdx + idx];
            for (row=0; row<NTURBVARS; row++) {
                for (col=0; col<NTURBVARS; col++) {
                    tmat[row][col] \
                        += tjmat[idx+neles*jdx+nface*neles*col+NTURBVARS*nface*neles*row]*fv;
                }
            }
        }
 
        // Computes Source term Jacobian
        if (rans_source_jacobian(uf, tmat, dsrcf) == UCFD_STATUS_NOT_SUPPORTED)
            printf("Error::Invalid `NTURBVARS` value\n");
 
        // Complete implicit operator
        for (kdx=0; kdx<NTURBVARS; kdx++) {
            tmat[kdx][kdx] += 1.0/(dt[idx]*factor);
        }
        
        // LU decomposition for inverse process
        ludcmp(NTURBVARS, tmat);
 
        // Allocate temporal matrix to diag array
        for (row=0; row<NTURBVARS; row++) {
            for (col=0; col<NTURBVARS; col++) {
                tdiag[idx+neles*col+neles*NTURBVARS*row] = tmat[row][col];
            }
        }
    }
}
 
 
void ns_serial_block_lower_sweep(UCFD_INT neles, UCFD_INT nface,
                                 UCFD_INT *nei_ele, UCFD_FLOAT *fnorm_vol,
                                 UCFD_FLOAT *rhsb, UCFD_FLOAT *dub, UCFD_FLOAT *diag, UCFD_FLOAT *fjmat)
{
    UCFD_INT idx, jdx, kdx, neib;
    UCFD_INT row, col;
    UCFD_FLOAT rhs[NFVARS], dmat[NFVARS][NFVARS];
    UCFD_FLOAT val, fv;
 
    // Lower sweep via mapping
    for (idx=0; idx<neles; idx++) {
        // Initialize
        for (kdx=0; kdx<NFVARS; kdx++) {
            rhs[kdx] = rhsb[idx+kdx*neles];
        }
 
        for (row=0; row<NFVARS; row++) {
            for (col=0; col<NFVARS; col++) {
                dmat[row][col] = diag[idx+neles*col+neles*NFVARS*row];
            }
        }
 
        // Only for neighbor cells
        for (jdx=0; jdx<nface; jdx++) {
            neib = nei_ele[idx+neles*jdx];
 
            if (neib != idx) {
                fv = fnorm_vol[neles*jdx + idx];
                // Matrix-Vector multiplication
                for (row=0; row<NFVARS; row++) {
                    val = 0.0;
                    for (col=0; col<NFVARS; col++) {
                        val += fjmat[idx+neles*jdx+nface*neles*col+NFVARS*nface*neles*row] \
                                * dub[neib+neles*col];
                    }
                    rhs[row] -= val*fv;
                }
            }
        }
 
        // Compute inverse of diagonal matrix multiplication
        lusub(NFVARS, dmat, rhs);
 
        // Update dub array
        for (kdx=0; kdx<NFVARS; kdx++) {
            dub[idx+neles*kdx] = rhs[kdx];
        }
    }
}
 
 
void rans_serial_block_lower_sweep(UCFD_INT neles, UCFD_INT nface,
                                   UCFD_INT *nei_ele, UCFD_FLOAT *fnorm_vol,
                                   UCFD_FLOAT *rhsb, UCFD_FLOAT *dub, UCFD_FLOAT *tdiag, UCFD_FLOAT *tjmat)
{
    UCFD_INT idx, jdx, kdx, neib;
    UCFD_INT row, col;
    UCFD_FLOAT val, fv;
    UCFD_FLOAT rhs[NTURBVARS], tmat[NTURBVARS][NTURBVARS];
 
    // Lower sweep via mapping
    for (idx=0; idx<neles; idx++) {
        // Initialize
        for (kdx=0; kdx<NTURBVARS; kdx++) {
            rhs[kdx] = rhsb[idx+(kdx+NFVARS)*neles];
        }
 
        for (row=0; row<NTURBVARS; row++) {
            for (col=0; col<NTURBVARS; col++) {
                tmat[row][col] = tdiag[idx+neles*col+neles*NTURBVARS*row];
            }
        }
 
        // Only for neighbor cells
        for (jdx=0; jdx<nface; jdx++) {
            neib = nei_ele[idx+neles*jdx];
 
            if (neib != idx) {
                fv = fnorm_vol[idx+neles*jdx];
                // Matrix-Vector multiplication
                for (row=0; row<NTURBVARS; row++) {
                    val = 0.0;
                    for (col=0; col<NTURBVARS; col++) {
                        val += tjmat[idx+neles*jdx+nface*neles*col+NTURBVARS*nface*neles*row] \
                                * dub[neib+neles*(col+NFVARS)];
                    }
                    rhs[row] -= val*fv;
                }
            }
        }
 
        // Compute inverse of diagonal matrix multiplication
        lusub(NTURBVARS, tmat, rhs);
 
        // Update dub array
        for (kdx=0; kdx<NTURBVARS; kdx++) {
            dub[idx+neles*(kdx+NFVARS)] = rhs[kdx];
        }
    }
}
 
 
void ns_serial_block_upper_sweep(UCFD_INT neles, UCFD_INT nface,
                                 UCFD_INT *nei_ele, UCFD_FLOAT *fnorm_vol,
                                 UCFD_FLOAT *rhsb, UCFD_FLOAT *dub, UCFD_FLOAT *diag, UCFD_FLOAT *fjmat)
{
    UCFD_INT idx, jdx, kdx, neib;
    UCFD_INT row, col;
    UCFD_FLOAT val, fv;
    UCFD_FLOAT rhs[NFVARS], dmat[NFVARS][NFVARS];
 
    // Upper sweep via mapping
    for (idx=neles-1; idx>-1; idx--) {
        // Initialize
        for (kdx=0; kdx<NFVARS; kdx++) {
            rhs[kdx] = rhsb[idx+kdx*neles];
        }
 
        for (row=0; row<NFVARS; row++) {
            for (col=0; col<NFVARS; col++) {
                dmat[row][col] = diag[idx+neles*col+neles*NFVARS*row];
            }
        }
 
        // Only for neighbor cells
        for (jdx=0; jdx<nface; jdx++) {
            neib = nei_ele[idx+neles*jdx];
 
            if (neib != idx) {
                fv = fnorm_vol[neles*jdx + idx];
                // Matrix-Vector multiplication
                for (row=0; row<NFVARS; row++) {
                    val = 0.0;
                    for (col=0; col<NFVARS; col++) {
                        val += fjmat[idx+neles*jdx+nface*neles*col+NFVARS*nface*neles*row] \
                                * dub[neib+neles*col];
                    }
                    rhs[row] -= val*fv;
                }
            }
        }
 
        // Compute inverse of diagonal matrix multiplication
        lusub(NFVARS, dmat, rhs);
 
        // Update dub array
        for (kdx=0; kdx<NFVARS; kdx++) {
            dub[idx+neles*kdx] = rhs[kdx];
        }
    }
}
 
 
void rans_serial_block_upper_sweep(UCFD_INT neles, UCFD_INT nface,
                                   UCFD_INT *nei_ele, UCFD_FLOAT *fnorm_vol,
                                   UCFD_FLOAT *rhsb, UCFD_FLOAT *dub, UCFD_FLOAT *tdiag, UCFD_FLOAT *tjmat)
{
    UCFD_INT idx, jdx, kdx, neib;
    UCFD_INT row, col;
    UCFD_FLOAT val, fv;
    UCFD_FLOAT rhs[NTURBVARS], tmat[NTURBVARS][NTURBVARS];
 
    // Lower sweep via mapping
    for (idx=neles-1; idx>-1; idx--) {
 
        // Initialize
        for (kdx=0; kdx<NTURBVARS; kdx++) {
            rhs[kdx] = rhsb[idx+(kdx+NFVARS)*neles];
        }
 
        for (row=0; row<NTURBVARS; row++) {
            for (col=0; col<NTURBVARS; col++) {
                tmat[row][col] = tdiag[idx+neles*col+neles*NTURBVARS*row];
            }
        }
 
        // Only for neighbor cells
        for (jdx=0; jdx<nface; jdx++) {
            neib = nei_ele[idx+neles*jdx];
 
            if (neib != idx) {
                fv = fnorm_vol[neles*jdx + idx];
                // Matrix-Vector multiplication
                for (row=0; row<NTURBVARS; row++) {
                    val = 0.0;
                    for (col=0; col<NTURBVARS; col++) {
                        val += tjmat[idx+neles*jdx+nface*neles*col+NTURBVARS*nface*neles*row] \
                                * dub[neib+neles*(col+NFVARS)];
                    }
                    rhs[row] -= val*fv;
                }
            }
        }
 
        // Compute inverse of diagonal matrix multiplication
        lusub(NTURBVARS, tmat, rhs);
 
        // Update dub array
        for (kdx=0; kdx<NTURBVARS; kdx++) {
            dub[idx+neles*(kdx+NFVARS)] = rhs[kdx];
        }
    }
}
 
 
void blusgs_serial_ns_update(UCFD_INT neles, UCFD_FLOAT *uptsb, UCFD_FLOAT *dub, UCFD_FLOAT *subres)
{
    UCFD_INT idx, kdx;
 
    for (idx=0; idx<neles; idx++) {
        for (kdx=0; kdx<NFVARS; kdx++) {
            uptsb[idx+neles*kdx] += dub[idx+neles*kdx];
 
            // Initialize dub array
            dub[idx+neles*kdx] = 0.0;
        }
        // Initialize sub-residual array
        subres[idx] = 0.0;
    }
}
 
 
void blusgs_serial_update(UCFD_INT neles, UCFD_FLOAT *uptsb, UCFD_FLOAT *dub, UCFD_FLOAT *subres)
{
    UCFD_INT idx, kdx;
 
    for (idx=0; idx<neles; idx++) {
        for (kdx=0; kdx<NVARS; kdx++) {
            uptsb[idx+neles*kdx] += dub[idx+neles*kdx];
 
            // Initialize dub array
            dub[idx+neles*kdx] = 0.0;
        }
        // Initialize sub-residual array
        subres[idx] = 0.0;
    }
}