/*! @par Revision history: - 24.10.2007, c */ int32 d_sd_st_grad_div( FMField *out, FMField *divU, FMField *gradU, FMField *divW, FMField *gradW, FMField *divMV, FMField *gradMV, FMField *coef, VolumeGeometry *vg_u, int32 mode ) { int32 ii, nQP, ret = RET_OK; FMField *scalar1 = 0, *scalar2 = 0; nQP = vg_u->bfGM->nLev; fmf_createAlloc( &scalar1, 1, nQP, 1, 1 ); if (mode == 1) { fmf_createAlloc( &scalar2, 1, nQP, 1, 1 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( coef, ii ); FMF_SetCell( divU, ii ); FMF_SetCell( divW, ii ); FMF_SetCell( vg_u->det, ii ); if (mode == 0) { // (div u, div w) fmf_mulATB_nn( scalar1, divU, divW ); fmf_mul( scalar1, coef->val ); fmf_sumLevelsMulF( out, scalar1, vg_u->det->val ); } else if (mode == 1) { FMF_SetCell( divMV, ii ); FMF_SetCell( gradU, ii ); FMF_SetCell( gradW, ii ); FMF_SetCell( gradMV, ii ); // div u div w div nu ... fmf_mulATB_nn( scalar1, divU, divW ); fmf_mulATB_nn( scalar2, divMV, scalar1 ); // ... - (gu : gnu^T) div w ... sub_mul_gradddgrad_scalar( scalar2, gradMV, gradU, divW ); // ... - (gw : gnu^T) div u sub_mul_gradddgrad_scalar( scalar2, gradMV, gradW, divU ); fmf_mul( scalar2, coef->val ); fmf_sumLevelsMulF( out, scalar2, vg_u->det->val ); } ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &scalar1 ); if (mode == 1) { fmf_freeDestroy( &scalar2 ); } return( ret ); }
/*! @par Revision history: - 21.11.2006, c */ int32 dw_mass( FMField *out, FMField *coef, FMField *state, FMField *bf, VolumeGeometry *vg, int32 isDiff ) { int32 ii, dim, nQP, nEP, ret = RET_OK; FMField *ftfu = 0, *ftf1 = 0, *ftf = 0; nQP = vg->bfGM->nLev; nEP = vg->bfGM->nCol; dim = vg->bfGM->nRow; if (isDiff) { fmf_createAlloc( &ftf, 1, nQP, nEP * dim, nEP * dim ); fmf_createAlloc( &ftf1, 1, nQP, nEP, nEP ); fmf_mulATB_nn( ftf1, bf, bf ); for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( coef, ii ); FMF_SetCell( vg->det, ii ); bf_buildFTF( ftf, ftf1 ); fmf_mul( ftf, coef->val ); fmf_sumLevelsMulF( out, ftf, vg->det->val ); ERR_CheckGo( ret ); } } else { fmf_createAlloc( &ftfu, 1, nQP, dim * nEP, 1 ); for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( state, ii ); FMF_SetCell( coef, ii ); FMF_SetCell( vg->det, ii ); bf_actt( ftfu, bf, state ); fmf_mul( ftfu, coef->val ); fmf_sumLevelsMulF( out, ftfu, vg->det->val ); ERR_CheckGo( ret ); } } end_label: if (isDiff) { fmf_freeDestroy( &ftf1 ); fmf_freeDestroy( &ftf ); } else { fmf_freeDestroy( &ftfu ); } return( ret ); }
int32 dw_surface_dot_vector( FMField *out, FMField *coef, FMField *val_qp, SurfaceGeometry *rsg, SurfaceGeometry *csg, int32 isDiff ) { int32 ii, dim, nQP, nEPR, nEPC, ret = RET_OK; FMField *ftfu = 0, *ftf1 = 0, *ftf = 0; nQP = rsg->normal->nLev; dim = rsg->normal->nRow; nEPR = rsg->bf->nCol; nEPC = csg->bf->nCol; if (isDiff) { fmf_createAlloc( &ftf, 1, nQP, nEPR * dim, nEPC * dim ); fmf_createAlloc( &ftf1, 1, nQP, nEPR, nEPC ); } else { fmf_createAlloc( &ftfu, 1, nQP, dim * nEPR, 1 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCellX1( coef, ii ); FMF_SetCell( rsg->det, ii ); FMF_SetCellX1( rsg->bf, ii ); if (isDiff) { FMF_SetCellX1( csg->bf, ii ); fmf_mulATB_nn( ftf1, rsg->bf, csg->bf ); bf_buildFTF( ftf, ftf1 ); fmf_mul( ftf, coef->val ); fmf_sumLevelsMulF( out, ftf, rsg->det->val ); } else { FMF_SetCell( val_qp, ii ); bf_actt( ftfu, rsg->bf, val_qp ); fmf_mul( ftfu, coef->val ); fmf_sumLevelsMulF( out, ftfu, rsg->det->val ); } ERR_CheckGo( ret ); } end_label: if (isDiff) { fmf_freeDestroy( &ftf1 ); fmf_freeDestroy( &ftf ); } else { fmf_freeDestroy( &ftfu ); } return( ret ); }
int32 dw_surface_s_v_dot_n(FMField *out, FMField *coef, FMField *val_qp, Mapping *rsg, Mapping *csg, int32 isDiff) { int32 ii, dim, nQP, nEPR, nEPC, ret = RET_OK; FMField *aux1 = 0, *aux2 = 0; nQP = rsg->det->nLev; dim = csg->normal->nRow; nEPR = rsg->bf->nCol; nEPC = csg->bf->nCol; if (isDiff) { fmf_createAlloc(&aux2, 1, nQP, nEPR, dim * nEPC); fmf_createAlloc(&aux1, 1, nQP, dim * nEPC, 1); } else { fmf_createAlloc(&aux2, 1, nQP, nEPR, 1); fmf_createAlloc(&aux1, 1, nQP, 1, 1); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell(out, ii); FMF_SetCellX1(coef, ii); FMF_SetCell(rsg->det, ii); FMF_SetCellX1(rsg->bf, ii); FMF_SetCell(csg->normal, ii); if (isDiff) { FMF_SetCellX1(csg->bf, ii); bf_actt(aux1, csg->bf, csg->normal); fmf_mulATBT_nn(aux2, rsg->bf, aux1); fmf_mul(aux2, coef->val); fmf_sumLevelsMulF(out, aux2, rsg->det->val); } else { FMF_SetCell(val_qp, ii); fmf_mulATB_nn(aux1, csg->normal, val_qp); fmf_mulATB_nn(aux2, rsg->bf, aux1); fmf_mul(aux2, coef->val); fmf_sumLevelsMulF(out, aux2, rsg->det->val); } ERR_CheckGo( ret ); } end_label: fmf_freeDestroy(&aux1); fmf_freeDestroy(&aux2); return( ret ); }
/*! @par Revision history: - 23.01.2006, c - 02.03.2006 - 27.07.2006 */ int32 d_of_nsMinGrad( FMField *out, FMField *grad, FMField *viscosity, VolumeGeometry *vg ) { int32 ii, nQP, ret = RET_OK; float64 aux; FMField *out1 = 0, *gvel2 = 0; nQP = vg->bfGM->nLev; fmf_createAlloc( &out1, 1, 1, 1, 1 ); fmf_createAlloc( &gvel2, 1, nQP, 1, 1 ); FMF_SetFirst( out ); aux = 0.0; for (ii = 0; ii < grad->nCell; ii++) { FMF_SetCell( grad, ii ); FMF_SetCell( viscosity, ii ); FMF_SetCell( vg->det, ii ); fmf_mulATB_nn( gvel2, grad, grad ); fmf_mul( gvel2, viscosity->val ); fmf_sumLevelsMulF( out1, gvel2, vg->det->val ); aux += out1->val[0]; ERR_CheckGo( ret ); } out->val[0] = aux * 0.5; end_label: fmf_freeDestroy( &out1 ); fmf_freeDestroy( &gvel2 ); return( ret ); }
/*! mode == 0: \int pq mode == 1: \int pq div V Works for both scalars and vectors. @par Revision history: - 24.02.2006, c - 27.02.2006 */ int32 d_sd_volume_dot( FMField *out, FMField *stateP, FMField *stateQ, FMField *divMV, VolumeGeometry *vg, int32 mode ) { int32 ii, nQP, ret = RET_OK; FMField *pq = 0; nQP = vg->bfGM->nLev; fmf_createAlloc( &pq, 1, nQP, 1, 1 ); for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( stateP, ii ); FMF_SetCell( stateQ, ii ); FMF_SetCell( vg->det, ii ); fmf_mulATB_nn( pq, stateP, stateQ ); if (mode == 1) { FMF_SetCell( divMV, ii ); fmf_mul( pq, divMV->val ); } fmf_sumLevelsMulF( out, pq, vg->det->val ); ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &pq ); return( ret ); }
/*! @par Revision history: - 22.03.2006, c */ int32 d_sd_convect( FMField *out, FMField *stateU, FMField *gradU, FMField *stateW, FMField *divMV, FMField *gradMV, VolumeGeometry *vg_u, int32 mode ) { int32 ii, dim, nQP, ret = RET_OK; FMField *aux11 = 0, *aux = 0, *fwgu = 0, *fwgugmv = 0; FMField gum[1], gmvm[1]; nQP = vg_u->bfGM->nLev; dim = vg_u->bfGM->nRow; gum->nAlloc = -1; fmf_pretend( gum, gradU->nCell, nQP, dim, dim, gradU->val0 ); fmf_createAlloc( &fwgu, 1, nQP, 1, dim ); fmf_createAlloc( &aux11, 1, nQP, 1, 1 ); if (mode == 1) { gmvm->nAlloc = -1; fmf_pretend( gmvm, gradMV->nCell, nQP, dim, dim, gradMV->val0 ); fmf_createAlloc( &fwgugmv, 1, nQP, 1, dim ); fmf_createAlloc( &aux, 1, nQP, 1, 1 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( stateU, ii ); FMF_SetCell( stateW, ii ); FMF_SetCell( gum, ii ); FMF_SetCell( vg_u->det, ii ); fmf_mulATB_nn( fwgu, stateW, gum ); fmf_mulAB_nn( aux11, fwgu, stateU ); if (mode == 1) { FMF_SetCell( divMV, ii ); FMF_SetCell( gmvm, ii ); fmf_mul( aux11, divMV->val ); fmf_mulAB_nn( fwgugmv, fwgu, gmvm ); fmf_mulAB_nn( aux, fwgugmv, stateU ); fmf_subAB_nn( aux11, aux11, aux ); } fmf_sumLevelsMulF( out, aux11, vg_u->det->val ); ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &aux11 ); fmf_freeDestroy( &fwgu ); if (mode == 1) { fmf_freeDestroy( &fwgugmv ); fmf_freeDestroy( &aux ); } return( ret ); }
/*! @par Revision history: - 04.09.2007, c */ int32 d_mass_scalar( FMField *out, FMField *coef, FMField *stateP, FMField *stateQ, FMField *bf, VolumeGeometry *vg ) { int32 ii, dim, nQP, ret = RET_OK; FMField *qftfp = 0; nQP = vg->bfGM->nLev; dim = vg->bfGM->nRow; fmf_createAlloc( &qftfp, 1, nQP, 1, 1 ); for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( stateP, ii ); FMF_SetCell( stateQ, ii ); FMF_SetCell( vg->det, ii ); if (coef->nCell > 1) { FMF_SetCell( coef, ii ); } fmf_mulATB_nn( qftfp, stateQ, stateP ); fmf_mul( qftfp, coef->val ); fmf_sumLevelsMulF( out, qftfp, vg->det->val ); ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &qftfp ); return( ret ); }
/*! @par Revision history: - 01.02.2008, c */ int32 dw_volume_dot_scalar( FMField *out, FMField *coef, FMField *val_qp, Mapping *rvg, Mapping *cvg, int32 isDiff ) { int32 ii, nQP, nEPR, nEPC, ret = RET_OK; FMField *ftfp = 0, *ftf = 0, *cftf = 0; nQP = rvg->nQP; nEPR = rvg->bf->nCol; nEPC = cvg->bf->nCol; if (isDiff) { fmf_createAlloc( &ftf, 1, nQP, nEPR, nEPC ); fmf_createAlloc( &cftf, 1, nQP, nEPR, nEPC ); } else { fmf_createAlloc( &ftfp, 1, nQP, nEPR, 1 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( rvg->det, ii ); FMF_SetCellX1( coef, ii ); FMF_SetCellX1( rvg->bf, ii ); if (isDiff) { FMF_SetCellX1( cvg->bf, ii ); fmf_mulATB_nn( ftf, rvg->bf, cvg->bf ); fmf_mulAF( cftf, ftf, coef->val ); fmf_sumLevelsMulF( out, cftf, rvg->det->val ); } else { FMF_SetCell( val_qp, ii ); bf_actt( ftfp, rvg->bf, val_qp ); fmf_mul( ftfp, coef->val ); fmf_sumLevelsMulF( out, ftfp, rvg->det->val ); } ERR_CheckGo( ret ); } end_label: if (isDiff) { fmf_freeDestroy( &ftf ); fmf_freeDestroy( &cftf ); } else { fmf_freeDestroy( &ftfp ); } return( ret ); }
/*! @par Revision history: - 06.03.2006, c - 24.10.2007 */ int32 d_sd_div( FMField *out, FMField *divU, FMField *gradU, FMField *stateP, FMField *divMV, FMField *gradMV, VolumeGeometry *vg_u, int32 mode ) { int32 ii, nQP, ret = RET_OK; FMField *aux11 = 0; nQP = vg_u->bfGM->nLev; fmf_createAlloc( &aux11, 1, nQP, 1, 1 ); for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( stateP, ii ); FMF_SetCell( divU, ii ); FMF_SetCell( vg_u->det, ii ); fmf_mulAB_nn( aux11, stateP, divU ); if (mode == 1) { FMF_SetCell( gradU, ii ); FMF_SetCell( divMV, ii ); FMF_SetCell( gradMV, ii ); fmf_mul( aux11, divMV->val ); sub_mul_gradddgrad_scalar( aux11, gradU, gradMV, stateP ); } fmf_sumLevelsMulF( out, aux11, vg_u->det->val ); ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &aux11 ); return( ret ); }
int32 dw_v_dot_grad_s_sw( FMField *out, FMField *coef, FMField *val_qp, Mapping *vvg, Mapping *svg, int32 isDiff ) { int32 ii, nc, nEPV, nEPS, dim, nQP, ret = RET_OK; FMField *gtf = 0, *ctf = 0, *ct = 0; nQP = vvg->bfGM->nLev; dim = vvg->bfGM->nRow; nEPS = svg->bfGM->nCol; nEPV = vvg->bf->nCol; nc = coef->nCol; if (isDiff == 1) { fmf_createAlloc( >f, 1, nQP, nEPS, dim * nEPV ); if (nc > 1) { fmf_createAlloc( &ctf, 1, nQP, dim, dim * nEPV ); fmf_createAlloc( &ct, 1, nQP, dim, dim ); } else { // Gc^T. fmf_createAlloc( &ctf, 1, nQP, nEPS, dim ); } } else { fmf_createAlloc( >f, 1, nQP, nEPS, 1 ); if (nc > 1) { fmf_createAlloc( &ctf, 1, nQP, dim, 1 ); } } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCellX1( coef, ii ); FMF_SetCell( svg->bfGM, ii ); FMF_SetCell( vvg->det, ii ); if (isDiff == 1) { FMF_SetCellX1( vvg->bf, ii ); if (nc == 1) { // Transpose Gc. fmf_mulATC( ctf, svg->bfGM, 1.0 ); // Gc^T Phi. bf_ract( gtf, vvg->bf, ctf ); fmf_mul( gtf, coef->val ); } else { // Transpose C. fmf_mulATC( ct, coef, 1.0 ); // Gc^T C^T Phi. bf_ract( ctf, vvg->bf, ct ); fmf_mulATB_nn( gtf, svg->bfGM, ctf ); } } else { FMF_SetCell( val_qp, ii ); if (nc == 1) { fmf_mulATB_nn( gtf, svg->bfGM, val_qp ); fmf_mul( gtf, coef->val ); } else { // Gc^T C^T Phi v. fmf_mulATB_nn( ctf, coef, val_qp ); fmf_mulATB_nn( gtf, svg->bfGM, ctf ); } } fmf_sumLevelsMulF( out, gtf, vvg->det->val ); ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( >f ); fmf_freeDestroy( &ctf ); fmf_freeDestroy( &ct ); return( ret ); }
int32 dw_v_dot_grad_s_vw( FMField *out, FMField *coef, FMField *grad, Mapping *vvg, Mapping *svg, int32 isDiff ) { int32 ii, nc, nEPV, nEPS, dim, nQP, ret = RET_OK; FMField *ftg = 0, *cg = 0; nQP = vvg->bfGM->nLev; dim = vvg->bfGM->nRow; nEPS = svg->bfGM->nCol; nEPV = vvg->bf->nCol; nc = coef->nCol; if (isDiff == 1) { fmf_createAlloc( &ftg, 1, nQP, dim * nEPV, nEPS ); if (nc > 1) { fmf_createAlloc( &cg, 1, nQP, dim, nEPS ); } } else { fmf_createAlloc( &ftg, 1, nQP, dim * nEPV, 1 ); if (nc > 1) { fmf_createAlloc( &cg, 1, nQP, dim, 1 ); } } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCellX1( coef, ii ); FMF_SetCell( vvg->det, ii ); FMF_SetCellX1( vvg->bf, ii ); if (isDiff == 1) { FMF_SetCell( svg->bfGM, ii ); if (nc == 1) { bf_actt( ftg, vvg->bf, svg->bfGM ); fmf_mul( ftg, coef->val ); } else { // Phi^T C Gc fmf_mulAB_nn( cg, coef, svg->bfGM ); bf_actt( ftg, vvg->bf, cg ); } } else { FMF_SetCell( grad, ii ); if (nc == 1) { bf_actt_c1( ftg, vvg->bf, grad ); fmf_mul( ftg, coef->val ); } else { // Phi^T C Gc s fmf_mulAB_nn( cg, coef, grad ); bf_actt( ftg, vvg->bf, cg ); } } fmf_sumLevelsMulF( out, ftg, vvg->det->val ); ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &ftg ); fmf_freeDestroy( &cg ); return( ret ); }
/*! @par Revision history: - 21.11.2006, c */ int32 dw_volume_dot_vector( FMField *out, FMField *coef, FMField *val_qp, Mapping *rvg, Mapping *cvg, int32 isDiff ) { int32 ii, dim, nc, nQP, nEPR, nEPC, ret = RET_OK; FMField *ftfu = 0, *ftf1 = 0, *ftf = 0,*cf = 0, *cfu = 0; nQP = rvg->nQP; dim = rvg->dim; nEPR = rvg->bf->nCol; nEPC = cvg->bf->nCol; nc = coef->nCol; if (isDiff) { fmf_createAlloc( &ftf, 1, nQP, nEPR * dim, nEPC * dim ); if (nc == 1) { fmf_createAlloc( &ftf1, 1, nQP, nEPR, nEPC ); } else { fmf_createAlloc( &cf, 1, nQP, dim, dim * nEPC ); } } else { fmf_createAlloc( &ftfu, 1, nQP, dim * nEPR, 1 ); if (nc > 1) { fmf_createAlloc( &cfu, 1, nQP, dim, 1 ); } } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCellX1( coef, ii ); FMF_SetCell( rvg->det, ii ); FMF_SetCellX1( rvg->bf, ii ); if (isDiff) { FMF_SetCellX1( cvg->bf, ii ); if (nc == 1) { fmf_mulATB_nn( ftf1, rvg->bf, cvg->bf ); bf_buildFTF( ftf, ftf1 ); fmf_mul( ftf, coef->val ); } else { bf_ract( cf, cvg->bf, coef ); bf_actt( ftf, rvg->bf, cf ); } fmf_sumLevelsMulF( out, ftf, rvg->det->val ); } else { FMF_SetCell( val_qp, ii ); if (nc == 1) { bf_actt( ftfu, rvg->bf, val_qp ); fmf_mul( ftfu, coef->val ); } else { fmf_mulAB_nn( cfu, coef, val_qp ); bf_actt( ftfu, rvg->bf, cfu ); } fmf_sumLevelsMulF( out, ftfu, rvg->det->val ); } ERR_CheckGo( ret ); } end_label: if (isDiff) { fmf_freeDestroy( &ftf ); if (nc == 1) { fmf_freeDestroy( &ftf1 ); } else { fmf_freeDestroy( &cf ); } } else { fmf_freeDestroy( &ftfu ); if (nc > 1) { fmf_freeDestroy( &cfu ); } } return( ret ); }
/*! @par Revision history: - 01.02.2008, c */ int32 dw_mass_scalar_variable( FMField *out, FMField *coef, FMField *state, int32 offset, FMField *bf, VolumeGeometry *vg, int32 *conn, int32 nEl, int32 nEP, int32 *elList, int32 elList_nRow, int32 isDiff ) { int32 ii, iel, dim, nQP, ret = RET_OK; FMField *st = 0, *fp = 0, *ftfp = 0, *ftf = 0, *cftf = 0; nQP = vg->bfGM->nLev; dim = vg->bfGM->nRow; /* output( "%d %d %d %d %d %d\n", offset, nEl, nEP, nQP, dim, elList_nRow ); */ if (isDiff) { fmf_createAlloc( &ftf, 1, nQP, nEP, nEP ); fmf_createAlloc( &cftf, 1, nQP, nEP, nEP ); fmf_mulATB_nn( ftf, bf, bf ); for (ii = 0; ii < elList_nRow; ii++) { iel = elList[ii]; FMF_SetCell( out, ii ); FMF_SetCell( coef, iel ); FMF_SetCell( vg->det, iel ); fmf_mulAF( cftf, ftf, coef->val ); fmf_sumLevelsMulF( out, cftf, vg->det->val ); ERR_CheckGo( ret ); } } else { state->val = FMF_PtrFirst( state ) + offset; fmf_createAlloc( &st, 1, 1, 1, nEP ); fmf_createAlloc( &fp, 1, nQP, 1, 1 ); fmf_createAlloc( &ftfp, 1, nQP, nEP, 1 ); for (ii = 0; ii < elList_nRow; ii++) { iel = elList[ii]; FMF_SetCell( out, ii ); FMF_SetCell( coef, iel ); FMF_SetCell( vg->det, iel ); ele_extractNodalValuesDBD( st, state, conn + nEP * iel ); bf_act( fp, bf, st ); bf_actt( ftfp, bf, fp ); fmf_mul( ftfp, coef->val ); fmf_sumLevelsMulF( out, ftfp, vg->det->val ); ERR_CheckGo( ret ); } } end_label: if (isDiff) { fmf_freeDestroy( &ftf ); fmf_freeDestroy( &cftf ); } else { fmf_freeDestroy( &st ); fmf_freeDestroy( &fp ); fmf_freeDestroy( &ftfp ); } return( ret ); }
/*! @par Revision history: - 25.10.2007, c - 29.10.2007 */ int32 d_sd_st_pspg_c( FMField *out, FMField *stateB, FMField *gradU, FMField *gradR, FMField *divMV, FMField *gradMV, FMField *coef, VolumeGeometry *vg_u, int32 mode ) { int32 ii, dim, nQP, ret = RET_OK; FMField *fBgU = 0, *fBgMV = 0, *fBgMVgU = 0, *gMVgR = 0; FMField *scalar1 = 0, *scalar2 = 0; nQP = vg_u->bfGM->nLev; dim = vg_u->bfGM->nRow; fmf_createAlloc( &fBgU, 1, nQP, 1, dim ); fmf_createAlloc( &scalar1, 1, nQP, 1, 1 ); if (mode == 1) { fmf_createAlloc( &scalar2, 1, nQP, 1, 1 ); fmf_createAlloc( &fBgMV, 1, nQP, 1, dim ); fmf_createAlloc( &fBgMVgU, 1, nQP, 1, dim ); fmf_createAlloc( &gMVgR, 1, nQP, dim, 1 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( stateB, ii ); FMF_SetCell( gradU, ii ); FMF_SetCell( gradR, ii ); FMF_SetCell( vg_u->det, ii ); FMF_SetCell( coef, ii ); // b grad u. fmf_mulATBT_nn( fBgU, stateB, gradU ); // (grad r, b grad u). fmf_mulATBT_nn( scalar1, gradR, fBgU ); if (mode == 0) { fmf_mul( scalar1, coef->val ); fmf_sumLevelsMulF( out, scalar1, vg_u->det->val ); } else if (mode == 1) { FMF_SetCell( divMV, ii ); FMF_SetCell( gradMV, ii ); // b grad nu. fmf_mulATBT_nn( fBgMV, stateB, gradMV ); // (grad r, b grad u) div nu ... fmf_mulATB_nn( scalar2, divMV, scalar1 ); // ... - (grad nu grad r, b grad u) ... fmf_mulATB_nn( gMVgR, gradMV, gradR ); fmf_mulATBT_nn( scalar1, gMVgR, fBgU ); fmf_subAB_nn( scalar2, scalar2, scalar1 ); // ... - (grad r, b grad nu grad u) ... fmf_mulABT_nn( fBgMVgU, fBgMV, gradU ); fmf_mulATBT_nn( scalar1, gradR, fBgMVgU ); fmf_subAB_nn( scalar2, scalar2, scalar1 ); fmf_mul( scalar2, coef->val ); fmf_sumLevelsMulF( out, scalar2, vg_u->det->val ); } ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &scalar1 ); fmf_freeDestroy( &fBgU ); if (mode == 1) { fmf_freeDestroy( &scalar2 ); fmf_freeDestroy( &fBgMV ); fmf_freeDestroy( &fBgMVgU ); fmf_freeDestroy( &gMVgR ); } return( ret ); }
/*! @par Revision history: - 08.01.2006, c - 09.01.2006 - 27.02.2006 - 06.03.2006 - 07.03.2006 */ int32 d_sd_div_grad( FMField *out, FMField *gradU, FMField *gradW, FMField *divMV, FMField *gradMV, FMField *viscosity, VolumeGeometry *vg_u, int32 mode ) { int32 ii, dim, nQP, ret = RET_OK; FMField *uvel = 0, *aux = 0, *aux1 = 0, *aux2 = 0, *aux3 = 0; FMField gum[1], gwm[1], gmvm[1], aux3m[1]; nQP = vg_u->bfGM->nLev; dim = vg_u->bfGM->nRow; fmf_createAlloc( &uvel, 1, nQP, 1, 1 ); if (mode == 1) { fmf_createAlloc( &aux, 1, 1, 1, 1 ); fmf_createAlloc( &aux1, 1, nQP, 1, 1 ); fmf_createAlloc( &aux2, 1, nQP, 1, 1 ); fmf_createAlloc( &aux3, 1, nQP, dim * dim, 1 ); aux3m->nAlloc = -1; fmf_pretend( aux3m, 1, nQP, dim, dim, aux3->val ); gum->nAlloc = -1; fmf_pretend( gum, gradU->nCell, nQP, dim, dim, gradU->val0 ); gwm->nAlloc = -1; fmf_pretend( gwm, gradW->nCell, nQP, dim, dim, gradW->val0 ); gmvm->nAlloc = -1; fmf_pretend( gmvm, gradMV->nCell, nQP, dim, dim, gradMV->val0 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( gradU, ii ); FMF_SetCell( gradW, ii ); FMF_SetCell( viscosity, ii ); FMF_SetCell( vg_u->det, ii ); // (gu:gw) fmf_mulATB_nn( uvel, gradW, gradU ); if (mode == 0) { fmf_mul( uvel, viscosity->val ); fmf_sumLevelsMulF( out, uvel, vg_u->det->val ); } else if (mode == 1) { FMF_SetCell( divMV, ii ); FMF_SetCell( gum, ii ); FMF_SetCell( gwm, ii ); FMF_SetCell( gmvm, ii ); // (gu:gw) div nu fmf_mulAB_nn( aux1, uvel, divMV ); fmf_mul( aux1, viscosity->val ); fmf_sumLevelsMulF( out, aux1, vg_u->det->val ); // (gu * gnu) : gw fmf_mulAB_nn( aux3m, gum, gmvm ); fmf_mulATB_nn( aux1, aux3, gradW ); // (gw * gnu) : gu fmf_mulAB_nn( aux3m, gwm, gmvm ); fmf_mulATB_nn( aux2, aux3, gradU ); fmf_addAB_nn( aux1, aux1, aux2 ); fmf_mul( aux1, viscosity->val ); fmf_sumLevelsMulF( aux, aux1, vg_u->det->val ); fmf_subAB_nn( out, out, aux ); } ERR_CheckGo( ret ); } end_label: if (mode == 1) { fmf_freeDestroy( &aux ); fmf_freeDestroy( &aux1 ); fmf_freeDestroy( &aux2 ); fmf_freeDestroy( &aux3 ); } return( ret ); }
/*! @par Revision history: - 11.10.2005, c - 12.10.2005 - 05.06.2006 - 06.06.2006 */ int32 vg_describe( VolumeGeometry *obj, float64 *coorIn, int32 nNod, int32 dim, int32 *conn, int32 nEl, int32 nEP, FMField *bfGR, FMField *weight ) { int32 iel, inod, idim, pos, iqp, nQP, ret = RET_OK; FMField *mtxMR = 0, *mtxMRI = 0, *coor = 0; nQP = bfGR->nLev; if (!((nEl == obj->nEl) && (dim == obj->dim) && (nQP == obj->nQP) && (nEP == obj->nEP))) { output( "nNod: %d, dim: %d, nEl: %d, nEP: %d\n", nNod, dim, nEl, nEP ); fmf_print( obj->bfGM, stdout, 1 ); fmf_print( bfGR, stdout, 1 ); fmf_print( weight, stdout, 1 ); errput( "size mismatch!\n" ); return( RET_Fail ); } fmf_createAlloc( &mtxMR, 1, nQP, dim, dim ); fmf_createAlloc( &mtxMRI, 1, nQP, dim, dim ); fmf_createAlloc( &coor, 1, 1, nEP, dim ); obj->totalVolume = 0.0; /* output( "nCell %d\n", obj->bfGM->nCell ); */ for (iel = 0; iel < obj->bfGM->nCell; iel++) { FMF_SetCell( obj->bfGM, iel ); FMF_SetCell( obj->det, iel ); FMF_SetCell( obj->volume, iel ); for (inod = 0; inod < nEP; inod++) { pos = dim*conn[inod]; for (idim = 0; idim < dim; idim++ ) { coor->val[dim*inod+idim] = coorIn[idim+pos]; } } // Jacobi matrix from reference to material system. fmf_mulATBT_1n( mtxMR, coor, bfGR ); // Its determinant, preweighted. geme_det3x3( obj->det->val, mtxMR ); for (iqp = 0; iqp < nQP; iqp++) { if (obj->det->val[iqp] <= MachEps) { errput( "warp violation %e at (iel: %d, iqp: %d)!\n", obj->det->val[iqp], iel, iqp ); } } fmf_mul( obj->det, weight->val ); // Element volume. geme_elementVolume( obj->volume->val, obj->det->val, nQP ); obj->totalVolume += obj->volume->val[0]; // Inverse of Jacobi matrix reference to material system. geme_invert3x3( mtxMRI, mtxMR ); // Base function gradient w.r.t. material system. fmf_mulATB_nn( obj->bfGM, mtxMRI, bfGR ); conn += nEP; /* output( "cell %d\n", iel ); */ /* fmf_print( coor, stdout, 0 ); */ /* fmf_print( obj->det, stdout, 0 ); */ ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &mtxMR ); fmf_freeDestroy( &mtxMRI ); fmf_freeDestroy( &coor ); return( ret ); }
/*! @par Revision history: - 25.10.2007, c - 29.10.2007 */ int32 d_sd_st_pspg_p( FMField *out, FMField *gradR, FMField *gradP, FMField *divMV, FMField *gradMV, FMField *coef, VolumeGeometry *vg_p, int32 mode ) { int32 ii, dim, nQP, ret = RET_OK; FMField *gMVgR = 0, *gMVgP = 0; FMField *scalar1 = 0, *scalar2 = 0; nQP = vg_p->bfGM->nLev; dim = gradR->nRow; fmf_createAlloc( &scalar1, 1, nQP, 1, 1 ); if (mode == 1) { fmf_createAlloc( &scalar2, 1, nQP, 1, 1 ); fmf_createAlloc( &gMVgP, 1, nQP, dim, 1 ); fmf_createAlloc( &gMVgR, 1, nQP, dim, 1 ); } for (ii = 0; ii < out->nCell; ii++) { FMF_SetCell( out, ii ); FMF_SetCell( gradR, ii ); FMF_SetCell( gradP, ii ); FMF_SetCell( vg_p->det, ii ); FMF_SetCell( coef, ii ); // (grad r, grad p). fmf_mulATB_nn( scalar1, gradR, gradP ); if (mode == 0) { fmf_mul( scalar1, coef->val ); fmf_sumLevelsMulF( out, scalar1, vg_p->det->val ); } else if (mode == 1) { FMF_SetCell( divMV, ii ); FMF_SetCell( gradMV, ii ); // grad nu grad r. fmf_mulATB_nn( gMVgR, gradMV, gradR ); // grad nu grad p. fmf_mulATB_nn( gMVgP, gradMV, gradP ); // (grad r, grad p) div nu ... fmf_mulATB_nn( scalar2, divMV, scalar1 ); // ... - (grad nu grad r, grad p) ... fmf_mulATB_nn( scalar1, gMVgR, gradP ); fmf_subAB_nn( scalar2, scalar2, scalar1 ); // ... - (grad nu grad p, grad r) ... fmf_mulATB_nn( scalar1, gMVgP, gradR ); fmf_subAB_nn( scalar2, scalar2, scalar1 ); fmf_mul( scalar2, coef->val ); fmf_sumLevelsMulF( out, scalar2, vg_p->det->val ); } ERR_CheckGo( ret ); } end_label: fmf_freeDestroy( &scalar1 ); if (mode == 1) { fmf_freeDestroy( &scalar2 ); fmf_freeDestroy( &gMVgP ); fmf_freeDestroy( &gMVgR ); } return( ret ); }