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:
- 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:
- 03.08.2006, c
- 01.12.2006
*/
int32 dw_biot_grad( FMField *out, float64 coef, FMField *pressure_qp,
FMField *mtxD, Mapping *svg, Mapping *vvg,
int32 isDiff )
{
int32 ii, nEPU, nEP, dim, nQP, ret = RET_OK;
FMField *dfp = 0, *gtdfp = 0, *gtd = 0, *gtdf = 0;
nQP = vvg->bfGM->nLev;
dim = vvg->bfGM->nRow;
nEPU = vvg->bfGM->nCol;
nEP = svg->bf->nCol;
/* fmf_print( mtxD, stdout, 0 ); */
if (isDiff == 1) {
fmf_createAlloc( >d, 1, nQP, dim * nEPU, 1 );
fmf_createAlloc( >df, 1, nQP, dim * nEPU, nEP );
} else {
int32 sym = (dim + 1) * dim / 2;
fmf_createAlloc( &dfp, 1, nQP, sym, 1 );
fmf_createAlloc( >dfp, 1, nQP, dim * nEPU, 1 );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( mtxD, ii );
FMF_SetCell( vvg->bfGM, ii );
FMF_SetCell( vvg->det, ii );
if (isDiff == 1) {
FMF_SetCellX1( svg->bf, ii );
form_sdcc_actOpGT_M3( gtd, vvg->bfGM, mtxD );
fmf_mulAB_nn( gtdf, gtd, svg->bf );
fmf_sumLevelsMulF( out, gtdf, vvg->det->val );
} else {
FMF_SetCell( pressure_qp, ii );
fmf_mulAB_nn( dfp, mtxD, pressure_qp );
form_sdcc_actOpGT_VS3( gtdfp, vvg->bfGM, dfp );
fmf_sumLevelsMulF( out, gtdfp, vvg->det->val );
}
ERR_CheckGo( ret );
}
// E.g. 1/dt.
fmfc_mulC( out, coef );
end_label:
if (isDiff) {
fmf_freeDestroy( >d );
fmf_freeDestroy( >df );
} else {
fmf_freeDestroy( &dfp );
fmf_freeDestroy( >dfp );
}
return( ret );
}
int32 dw_surface_flux(FMField *out, FMField *grad,
FMField *mat, FMField *bf, Mapping *sg,
int32 *fis, int32 nFa, int32 nFP, int32 mode)
{
int32 ii, ifa, dim, nQP, nEP, ret = RET_OK;
FMField *ntk = 0, *ntkg = 0, *out_qp = 0;
nQP = sg->normal->nLev;
dim = sg->normal->nRow;
nEP = sg->bfGM->nCol;
fmf_createAlloc(&ntk, 1, nQP, 1, dim);
if (mode) {
fmf_createAlloc(&ntkg, 1, nQP, 1, nEP);
fmf_createAlloc(&out_qp, 1, nQP, nEP, nEP);
} else {
fmf_createAlloc(&ntkg, 1, nQP, 1, 1);
fmf_createAlloc(&out_qp, 1, nQP, nEP, 1);
}
for (ii = 0; ii < out->nCell; ii++) {
ifa = fis[ii*nFP+1];
FMF_SetCell(out, ii);
FMF_SetCellX1(mat, ii);
FMF_SetCell(sg->det, ii);
FMF_SetCell(sg->normal, ii);
FMF_SetCell(bf, ifa);
fmf_mulATB_nn(ntk, sg->normal, mat);
if (mode) {
FMF_SetCell(sg->bfGM, ii);
fmf_mulAB_nn(ntkg, ntk, sg->bfGM);
} else {
FMF_SetCell(grad, ii);
fmf_mulAB_nn(ntkg, ntk, grad);
}
fmf_mulATB_nn(out_qp, bf, ntkg);
fmf_sumLevelsMulF(out, out_qp, sg->det->val);
ERR_CheckGo(ret);
}
end_label:
fmf_freeDestroy(&ntk);
fmf_freeDestroy(&ntkg);
fmf_freeDestroy(&out_qp);
return(ret);
}
/*!
@par Revision history:
- 20.12.2005, c
- 22.03.2006
- 27.07.2006
*/
int32 dw_adj_convect2( FMField *out, FMField *stateW, FMField *stateU,
VolumeGeometry *vg, int32 isDiff )
{
int32 ii, dim, nQP, nEP, ret = RET_OK;
FMField *vtg = 0, *ftvtg = 0;
FMField *futvtg = 0;
nQP = vg->bfGM->nLev;
nEP = vg->bfGM->nCol;
dim = vg->bfGM->nRow;
fmf_createAlloc( &vtg, 1, nQP, dim, nEP * dim );
if (isDiff) {
fmf_createAlloc( &ftvtg, 1, nQP, dim * nEP, dim * nEP );
} else {
fmf_createAlloc( &futvtg, 1, nQP, 1, dim * nEP );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( stateU, ii );
FMF_SetCell( vg->bfGM, ii );
FMF_SetCell( vg->det, ii );
convect_build_vtg( vtg, vg->bfGM, stateU );
if (isDiff) {
FMF_SetCellX1( vg->bf, ii );
bf_actt( ftvtg, vg->bf, vtg );
fmf_sumLevelsTMulF( out, ftvtg, vg->det->val );
} else {
FMF_SetCell( stateW, ii );
fmf_mulATB_nn( futvtg, stateW, vtg );
fmf_sumLevelsTMulF( out, futvtg, vg->det->val );
}
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &vtg );
if (isDiff) {
fmf_freeDestroy( &ftvtg );
} else {
fmf_freeDestroy( &futvtg );
}
return( ret );
}
/*!
@par Revision history:
- 12.12.2005, c
- 14.12.2005
- 22.03.2006
- 27.07.2006
*/
int32 dw_adj_convect1( FMField *out, FMField *stateW, FMField *gradU,
VolumeGeometry *vg, int32 isDiff )
{
int32 ii, dim, nQP, nEP, ret = RET_OK;
FMField *gf = 0, *ftgf = 0, *ftgfu = 0;
FMField *gfu = 0;
nQP = vg->bfGM->nLev;
nEP = vg->bfGM->nCol;
dim = vg->bfGM->nRow;
if (isDiff) {
fmf_createAlloc( &gf, 1, nQP, dim, dim * nEP );
fmf_createAlloc( &ftgf, 1, nQP, dim * nEP, dim * nEP );
} else {
fmf_createAlloc( &gfu, 1, nQP, dim, 1 );
fmf_createAlloc( &ftgfu, 1, nQP, dim * nEP, 1 );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( gradU, ii );
FMF_SetCell( vg->det, ii );
FMF_SetCellX1( vg->bf, ii );
if (isDiff) {
bf_ract( gf, vg->bf, gradU );
bf_actt( ftgf, vg->bf, gf );
fmf_sumLevelsMulF( out, ftgf, vg->det->val );
} else {
FMF_SetCell( stateW, ii );
fmf_mulAB_nn( gfu, gradU, stateW );
bf_actt( ftgfu, vg->bf, gfu );
fmf_sumLevelsMulF( out, ftgfu, vg->det->val );
}
ERR_CheckGo( ret );
}
end_label:
if (isDiff) {
fmf_freeDestroy( &gf );
fmf_freeDestroy( &ftgf );
} else {
fmf_freeDestroy( &gfu );
fmf_freeDestroy( &ftgfu );
}
return( ret );
}
/*!
@par Revision history:
- 23.03.2007, c
*/
int32 d_of_nsSurfMinDPress( FMField *out, FMField *pressure,
float64 weight, float64 bpress,
SurfaceGeometry *sg, int32 isDiff )
{
int32 ii, iqp, nQP, ret = RET_OK;
float64 aux;
FMField *out1 = 0, *pressQP = 0;
nQP = sg->det->nLev;
if (isDiff == 0) {
fmf_createAlloc( &out1, 1, 1, 1, 1 );
fmf_createAlloc( &pressQP, 1, nQP, 1, 1 );
aux = 0.0;
for (ii = 0; ii < pressure->nCell; ii++) {
FMF_SetCell( pressure, ii );
FMF_SetCell( sg->det, ii );
for (iqp = 0; iqp < nQP; iqp++) {
pressQP->val[iqp] -= pressure->val[iqp] - bpress;
}
fmf_sumLevelsMulF( out1, pressQP, sg->det->val );
aux += out1->val[0];
ERR_CheckGo( ret );
}
out->val[0] = aux * weight;
} else {
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( sg->det, ii );
FMF_SetCellX1( sg->bf, ii );
fmf_sumLevelsTMulF( out, sg->bf, sg->det->val );
ERR_CheckGo( ret );
}
fmfc_mulC( out, weight );
}
end_label:
if (isDiff == 0) {
fmf_freeDestroy( &out1 );
fmf_freeDestroy( &pressQP );
}
return( ret );
}
int32 dw_convect_v_grad_s( FMField *out, FMField *val_v, FMField *grad_s,
Mapping *vvg, Mapping *svg,
int32 isDiff )
{
int32 ii, nEPV, nEPS, dim, nQP, ret = RET_OK;
FMField *aux = 0, *out_qp = 0, *gst = 0;
nQP = vvg->bfGM->nLev;
dim = vvg->bfGM->nRow;
nEPS = svg->bfGM->nCol;
nEPV = vvg->bf->nCol;
if (isDiff == 0) {
fmf_createAlloc( &aux, 1, nQP, 1, 1 );
fmf_createAlloc( &out_qp, 1, nQP, nEPS, 1 );
} else if (isDiff == 1) { // d/ds.
fmf_createAlloc( &aux, 1, nQP, 1, nEPS );
fmf_createAlloc( &out_qp, 1, nQP, nEPS, nEPS );
} else { // d/dv.
fmf_createAlloc( &aux, 1, nQP, 1, dim * nEPV );
fmf_createAlloc( &out_qp, 1, nQP, nEPS, dim * nEPV );
fmf_createAlloc( &gst, 1, nQP, 1, dim );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCellX1( svg->bf, ii );
if (isDiff == 0) {
FMF_SetCell( val_v, ii );
FMF_SetCell( grad_s, ii );
// v^T Psi^T G_c s.
fmf_mulATB_nn( aux, val_v, grad_s );
// Phi^T v^T Psi^T G_c s.
fmf_mulATB_nn( out_qp, svg->bf, aux );
} else if (isDiff == 1) { // d/ds.
FMF_SetCell( val_v, ii );
FMF_SetCell( svg->bfGM, ii );
// v^T Psi^T G_c.
fmf_mulATB_nn( aux, val_v, svg->bfGM );
// Phi^T v^T Psi^T G_c.
fmf_mulATB_nn( out_qp, svg->bf, aux );
} else { // d/dv.
FMF_SetCell( grad_s, ii );
FMF_SetCellX1( vvg->bf, ii );
// s^T G_c^T - transpose grad_s.
fmf_mulATC( gst, grad_s, 1.0 );
// s^T G_c^T Psi.
bf_ract( aux, vvg->bf, gst );
// Phi^T s^T G_c^T Psi.
fmf_mulATB_nn( out_qp, svg->bf, aux );
}
fmf_sumLevelsMulF( out, out_qp, vvg->det->val );
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &aux );
fmf_freeDestroy( &out_qp );
fmf_freeDestroy( &gst );
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:
- 04.08.2006, c
- 01.12.2006
*/
int32 dw_biot_div( FMField *out, float64 coef, FMField *strain,
FMField *mtxD, Mapping *svg, Mapping *vvg,
int32 isDiff )
{
int32 ii, nEPP, nEP, dim, sym, nQP, ret = RET_OK;
FMField *dtg = 0, *ftdtg = 0, *dtgu = 0, *ftdtgu = 0;
FMField drow[1];
nQP = vvg->bfGM->nLev;
nEP = vvg->bfGM->nCol;
dim = vvg->bfGM->nRow;
sym = (dim + 1) * dim / 2;
nEPP = svg->bf->nCol;
/* fmf_print( mtxD, stdout, 0 ); */
if (isDiff == 1) {
fmf_createAlloc( &dtg, 1, nQP, 1, dim * nEP );
fmf_createAlloc( &ftdtg, 1, nQP, nEPP, dim * nEP );
drow->nAlloc = -1;
fmf_pretend( drow, 1, nQP, 1, sym, mtxD->val );
} else {
fmf_createAlloc( &dtgu, 1, nQP, 1, 1 );
fmf_createAlloc( &ftdtgu, 1, nQP, nEPP, 1 );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( mtxD, ii );
FMF_SetCell( vvg->bfGM, ii );
FMF_SetCell( vvg->det, ii );
FMF_SetCellX1( svg->bf, ii );
if (isDiff == 1) {
drow->val = mtxD->val;
form_sdcc_actOpG_RM3( dtg, drow, vvg->bfGM );
fmf_mulATB_nn( ftdtg, svg->bf, dtg );
fmf_sumLevelsMulF( out, ftdtg, vvg->det->val );
} else {
FMF_SetCell( strain, ii );
fmf_mulATB_nn( dtgu, mtxD, strain );
fmf_mulATB_nn( ftdtgu, svg->bf, dtgu );
fmf_sumLevelsMulF( out, ftdtgu, vvg->det->val );
}
ERR_CheckGo( ret );
}
// E.g. 1/dt.
fmfc_mulC( out, coef );
end_label:
if (isDiff) {
fmf_freeDestroy( &dtg );
fmf_freeDestroy( &ftdtg );
} else {
fmf_freeDestroy( &dtgu );
fmf_freeDestroy( &ftdtgu );
}
return( ret );
}
/*!
@par Revision history:
- 30.10.2007, c
*/
int32 dw_st_adj2_supg_p( FMField *out, FMField *gradU, FMField *stateR,
FMField *coef,
VolumeGeometry *vg_u, VolumeGeometry *vg_r,
int32 *conn_r, int32 nEl_r, int32 nEP_r,
int32 isDiff )
{
int32 ii, dim, nQP, nEP_u, ret = RET_OK;
FMField *stR = 0, *gUTg = 0, *fTgUTg = 0;
FMField *outqp = 0;
FMField stRv[1];
nQP = vg_u->bfGM->nLev;
nEP_u = vg_u->bfGM->nCol;
dim = vg_u->bfGM->nRow;
stateR->val = FMF_PtrFirst( stateR );
fmf_createAlloc( &gUTg, 1, nQP, dim, nEP_r );
fmf_createAlloc( &fTgUTg, 1, nQP, nEP_u * dim, nEP_r );
if (isDiff == 0) {
fmf_createAlloc( &outqp, 1, nQP, nEP_u * dim, 1 );
fmf_createAlloc( &stR, 1, 1, 1, nEP_r );
stRv->nAlloc = -1;
fmf_pretend( stRv, 1, 1, nEP_r, 1, stR->val );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( gradU, ii );
FMF_SetCell( vg_r->bfGM, ii );
FMF_SetCell( vg_u->det, ii );
FMF_SetCell( coef, ii );
FMF_SetCellX1( vg_u->bf, ii );
// (grad u, grad).
fmf_mulATB_nn( gUTg, gradU, vg_r->bfGM );
// (v grad u, grad).
bf_actt( fTgUTg, vg_u->bf, gUTg );
if (isDiff == 1) {
fmf_sumLevelsMulF( out, fTgUTg, vg_u->det->val );
} else {
ele_extractNodalValuesDBD( stR, stateR, conn_r + nEP_r * ii );
// (v grad u, grad r).
fmf_mulAB_n1( outqp, fTgUTg, stRv );
fmf_sumLevelsMulF( out, outqp, vg_u->det->val );
}
fmf_mulC( out, coef->val[0] );
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &gUTg );
fmf_freeDestroy( &fTgUTg );
if (isDiff == 0) {
fmf_freeDestroy( &stR );
fmf_freeDestroy( &outqp );
}
return( ret );
}
/*!
@par Revision history:
- 30.10.2007, c
*/
int32 dw_st_adj1_supg_p( FMField *out, FMField *stateW, FMField *gradP,
FMField *coef, VolumeGeometry *vg_w,
int32 *conn_w, int32 nEl_w, int32 nEP_w,
int32 isDiff )
{
int32 ii, dim, nQP, ret = RET_OK;
FMField *stW = 0, *gPTgT = 0, *fTgPTgT = 0;
FMField *outqp = 0;
FMField stWv[1];
nQP = vg_w->bfGM->nLev;
dim = vg_w->bfGM->nRow;
stateW->val = FMF_PtrFirst( stateW );
fmf_createAlloc( &gPTgT, 1, nQP, dim, nEP_w * dim );
fmf_createAlloc( &fTgPTgT, 1, nQP, nEP_w * dim, nEP_w * dim );
if (isDiff == 0) {
fmf_createAlloc( &outqp, 1, nQP, nEP_w * dim, 1 );
fmf_createAlloc( &stW, 1, 1, dim, nEP_w );
stWv->nAlloc = -1;
fmf_pretend( stWv, 1, 1, nEP_w * dim, 1, stW->val );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( gradP, ii );
FMF_SetCell( vg_w->bfGM, ii );
FMF_SetCell( vg_w->det, ii );
FMF_SetCell( coef, ii );
FMF_SetCellX1( vg_w->bf, ii );
// (grad p, grad).
convect_build_vtbg( gPTgT, vg_w->bfGM, gradP );
// (grad p, v grad).
bf_actt( fTgPTgT, vg_w->bf, gPTgT );
if (isDiff == 1) {
fmf_sumLevelsMulF( out, fTgPTgT, vg_w->det->val );
} else {
ele_extractNodalValuesDBD( stW, stateW, conn_w + nEP_w * ii );
// (grad p, v grad w).
fmf_mulAB_n1( outqp, fTgPTgT, stWv );
fmf_sumLevelsMulF( out, outqp, vg_w->det->val );
}
fmf_mulC( out, coef->val[0] );
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &gPTgT );
fmf_freeDestroy( &fTgPTgT );
if (isDiff == 0) {
fmf_freeDestroy( &stW );
fmf_freeDestroy( &outqp );
}
return( ret );
}
/*!
@par Revision history:
- 30.10.2007, c
*/
int32 dw_st_adj_supg_c( FMField *out, FMField *stateW,
FMField *stateU, FMField *gradU,
FMField *coef, VolumeGeometry *vg,
int32 *conn, int32 nEl, int32 nEP,
int32 isDiff )
{
int32 ii, dim, nQP, ret = RET_OK;
FMField *stW = 0, *gUfU = 0, *fUTg = 0;
FMField *gUfUTg = 0, *fTgUfUTg = 0;
FMField *gUfUTgT = 0, *fTgUfUTgT = 0;
FMField *outdqp = 0, *outqp = 0, *out1qp = 0, *out2qp = 0;
FMField stWv[1];
nQP = vg->bfGM->nLev;
dim = vg->bfGM->nRow;
stateW->val = FMF_PtrFirst( stateW );
fmf_createAlloc( &gUfU, 1, nQP, dim, 1 );
fmf_createAlloc( &gUfUTgT, 1, nQP, dim, nEP * dim );
fmf_createAlloc( &fTgUfUTgT, 1, nQP, nEP * dim, nEP * dim );
fmf_createAlloc( &fUTg, 1, nQP, dim, nEP * dim );
fmf_createAlloc( &gUfUTg, 1, nQP, dim, nEP * dim );
fmf_createAlloc( &fTgUfUTg, 1, nQP, nEP * dim, nEP * dim );
if (isDiff == 1) {
fmf_createAlloc( &outdqp, 1, nQP, dim * nEP, dim * nEP );
} else {
fmf_createAlloc( &stW, 1, 1, dim, nEP );
stWv->nAlloc = -1;
fmf_pretend( stWv, 1, 1, nEP * dim, 1, stW->val );
fmf_createAlloc( &out1qp, 1, nQP, dim * nEP, 1 );
fmf_createAlloc( &out2qp, 1, nQP, dim * nEP, 1 );
fmf_createAlloc( &outqp, 1, nQP, dim * nEP, 1 );
}
for (ii = 0; ii < out->nCell; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( stateU, ii );
FMF_SetCell( gradU, ii );
FMF_SetCell( vg->bfGM, ii );
FMF_SetCell( vg->det, ii );
FMF_SetCell( coef, ii );
FMF_SetCellX1( vg->bf, ii );
// u grad u.
fmf_mulAB_nn( gUfU, gradU, stateU );
// (u grad u, grad).
convect_build_vtbg( gUfUTgT, vg->bfGM, gUfU );
// (u grad u, v grad).
bf_actt( fTgUfUTgT, vg->bf, gUfUTgT );
// u grad.
convect_build_vtg( fUTg, vg->bfGM, stateU );
// (grad u, u^T grad).
fmf_mulAB_nn( gUfUTg, gradU, fUTg );
// (v grad u, u grad).
bf_actt( fTgUfUTg, vg->bf, gUfUTg );
if (isDiff == 1) {
fmf_addAB_nn( outdqp, fTgUfUTgT, fTgUfUTg );
fmf_sumLevelsMulF( out, outdqp, vg->det->val );
} else {
ele_extractNodalValuesDBD( stW, stateW, conn + nEP * ii );
// (u grad u, v grad w).
fmf_mulAB_n1( out1qp, fTgUfUTgT, stWv );
// (v grad u, u grad w).
fmf_mulAB_n1( out2qp, fTgUfUTg, stWv );
fmf_addAB_nn( outqp, out1qp, out2qp );
fmf_sumLevelsMulF( out, outqp, vg->det->val );
}
fmf_mulC( out, coef->val[0] );
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &gUfU );
fmf_freeDestroy( &gUfUTgT );
fmf_freeDestroy( &fTgUfUTgT );
fmf_freeDestroy( &fUTg );
fmf_freeDestroy( &gUfUTg );
fmf_freeDestroy( &fTgUfUTg );
if (isDiff) {
fmf_freeDestroy( &outdqp );
} else {
fmf_freeDestroy( &stW );
fmf_freeDestroy( &out1qp );
fmf_freeDestroy( &out2qp );
fmf_freeDestroy( &outqp );
}
return( ret );
}
