/*!
@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 );
}
