/*!
@par Revision history:
- 30.07.2007, from dw_hdpm_cache()
*/
int32 dq_cauchy_strain( FMField *out, FMField *state, int32 offset,
VolumeGeometry *vg,
int32 *conn, int32 nEl, int32 nEP )
{
int32 ii, dim, sym, nQP, ret = RET_OK;
FMField *st = 0, *disG = 0;
state->val = FMF_PtrFirst( state ) + offset;
nQP = vg->bfGM->nLev;
dim = vg->bfGM->nRow;
sym = (dim + 1) * dim / 2;
fmf_createAlloc( &st, 1, 1, nEP, dim );
fmf_createAlloc( &disG, 1, nQP, dim, dim );
for (ii = 0; ii < nEl; ii++) {
FMF_SetCell( out, ii );
FMF_SetCell( vg->bfGM, ii );
ele_extractNodalValuesNBN( st, state, conn + nEP * ii );
fmf_mulAB_n1( disG, vg->bfGM, st );
form_sdcc_strainCauchy_VS( out, disG );
/* fmf_print( out, stdout, 0 ); */
/* sys_pause(); */
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &st );
fmf_freeDestroy( &disG );
return( ret );
}
/*!
@par Revision history:
- 04.05.2007, c
- 30.05.2007
*/
int32 sg_evaluateBFBGM( SurfaceGeometry *obj, FMField *bfBGR,
float64 *coorIn, int32 nNod, int32 dim,
int32 *fis, int32 nFa, int32 nFP,
int32 *conn, int32 nEl, int32 nEP )
{
int32 ii, iel, ifa, inod, idim, pos, nQP, ret = RET_OK;
FMField *volCoor0 = 0, *mtxRM = 0, *mtxRMI = 0;
nQP = obj->normal->nLev;
/* output( "%d %d %d %d\n", dim, nQP, nEP, nNod ); */
fmf_createAlloc( &volCoor0, 1, 1, nEP, dim );
fmf_createAlloc( &mtxRM, 1, nQP, dim, dim );
fmf_createAlloc( &mtxRMI, 1, nQP, dim, dim );
for (ii = 0; ii < nFa; ii++) {
iel = fis[ii*nFP+0];
ifa = fis[ii*nFP+1];
FMF_SetCell( obj->bfBGM, ii );
FMF_SetCell( bfBGR, ifa );
for (inod = 0; inod < nEP; inod++) {
pos = dim*conn[nEP*iel+inod];
for (idim = 0; idim < dim; idim++ ) {
volCoor0->val[dim*inod+idim] = coorIn[idim+pos];
}
}
fmf_mulAB_n1( mtxRM, bfBGR, volCoor0 );
geme_invert3x3( mtxRMI, mtxRM );
fmf_mulAB_nn( obj->bfBGM, mtxRMI, bfBGR );
/* fmf_mulATBT_1n( mtxRM, volCoor0, bfBGR ); */
/* geme_invert3x3( mtxRMI, mtxRM ); */
/* fmf_mulATB_nn( obj->bfBGM, mtxRMI, bfBGR ); */
/* output( "%d %d %d\n", ii, iel, ifa); */
/* fmf_print( bfBGR, stdout, 0 ); */
/* fmf_print( volCoor0, stdout, 0 ); */
/* fmf_print( obj->bfBGM, stdout, 0 ); */
/* sys_pause(); */
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &volCoor0 );
fmf_freeDestroy( &mtxRM );
fmf_freeDestroy( &mtxRMI );
return( RET_OK );
}
/*!
Diffusion velocity.
@par Revision history:
- c: 07.09.2006, r: 06.05.2008
*/
int32 de_diffusion_velocity( FMField *out, FMField *state, int32 offset,
FMField *mtxD, VolumeGeometry *vg,
int32 *conn, int32 nEl, int32 nEP,
int32 *elList, int32 elList_nRow )
{
int32 ii, iel, dim, nQP, ret = RET_OK;
FMField *st = 0, *gp = 0, *dgp = 0;
nQP = vg->bfGM->nLev;
dim = vg->bfGM->nRow;
/* output( "%d %d %d %d %d %d\n", offset, nEl, nEP, nQP, dim, elList_nRow ); */
state->val = FMF_PtrFirst( state ) + offset;
fmf_createAlloc( &st, 1, 1, nEP, 1 );
fmf_createAlloc( &gp, 1, nQP, dim, 1 );
fmf_createAlloc( &dgp, 1, nQP, dim, 1 );
for (ii = 0; ii < elList_nRow; ii++) {
iel = elList[ii];
FMF_SetCell( out, ii );
FMF_SetCell( vg->bfGM, iel );
FMF_SetCell( vg->det, iel );
if (mtxD->nCell > 1) {
FMF_SetCell( mtxD, ii );
}
ele_extractNodalValuesNBN( st, state, conn + nEP * iel );
fmf_mulAB_n1( gp, vg->bfGM, st );
fmf_mulAB_nn( dgp, mtxD, gp );
fmf_sumLevelsMulF( out, dgp, vg->det->val );
ERR_CheckGo( ret );
}
fmfc_mulC( out, -1.0 );
end_label:
fmf_freeDestroy( &st );
fmf_freeDestroy( &gp );
fmf_freeDestroy( &dgp );
return( ret );
}
/*!
@par Revision history:
- 21.12.2005, c
- 05.09.2006
*/
int32 sg_describe( SurfaceGeometry *obj,
float64 *coorIn, int32 nNod, int32 dim,
int32 *fconn, int32 nFa, int32 nFP,
FMField *bfGR, FMField *weight )
{
int32 ii, pos, inod, idim, iqp, nQP, ret = RET_OK;
float64 c1, c2, c3, det;
float64 *jmat;
FMField *faceCoor = 0, *mtxRMS = 0;
nQP = bfGR->nLev;
if (!((nFa == obj->nFa) &&
(dim == obj->dim) &&
(nQP == obj->nQP) &&
(nFP == obj->nFP))) {
output( "nNod: %d, dim: %d, nFa: %d, nFP: %d\n", nNod, dim, nFa, nFP );
fmf_print( obj->normal, stdout, 1 );
fmf_print( bfGR, stdout, 1 );
fmf_print( weight, stdout, 1 );
errput( "size mismatch!\n" );
return( RET_Fail );
}
/* output( "%d %d %d %d\n", dim, nQP, nFP, nNod ); */
fmf_createAlloc( &faceCoor, 1, 1, nFP, dim );
fmf_createAlloc( &mtxRMS, 1, nQP, dim - 1, dim );
for (ii = 0; ii < nFa; ii++) {
FMF_SetCell( obj->normal, ii );
FMF_SetCell( obj->det, ii );
FMF_SetCell( obj->area, ii );
for (inod = 0; inod < nFP; inod++) {
pos = dim*fconn[inod];
for (idim = 0; idim < dim; idim++ ) {
faceCoor->val[dim*inod+idim] = coorIn[idim+pos];
}
}
/* fmf_print( faceCoor, stdout, 0 ); */
fmf_mulAB_n1( mtxRMS, bfGR, faceCoor );
/* Surface jacobian and normal. */
switch (dim) {
case 2:
/* dl = \norma{dx} = sqrt( dx^2 + dy^2 ) */
for (iqp = 0; iqp < nQP; iqp++) {
jmat = FMF_PtrLevel( mtxRMS, iqp );
c1 = jmat[0];
c2 = jmat[1];
det = sqrt( c1*c1 + c2*c2 );
obj->det->val[iqp] = det * weight->val[iqp];
/* Unit outward normal. */
obj->normal->val[2*(iqp)+0] = c2 / det;
obj->normal->val[2*(iqp)+1] = -c1 / det;
}
break;
case 3:
/* dS = \norma{dx x dy} */
for (iqp = 0; iqp < nQP; iqp++) {
jmat = FMF_PtrLevel( mtxRMS, iqp );
c1 = jmat[1] * jmat[5] - jmat[4] * jmat[2];
c2 = jmat[0] * jmat[5] - jmat[3] * jmat[2];
c3 = jmat[0] * jmat[4] - jmat[1] * jmat[3];
det = sqrt( c1*c1 + c2*c2 + c3*c3 );
/* printf( "s: %f %f %f %f\n", c1, -c2, c3, det ); */
obj->det->val[iqp] = det * weight->val[iqp];
/* Unit outward normal. */
obj->normal->val[3*(iqp)+0] = c1 / det;
obj->normal->val[3*(iqp)+1] = -c2 / det;
obj->normal->val[3*(iqp)+2] = c3 / det;
}
break;
default:
errput( ErrHead "ERR_Switch\n" );
}
// Element area.
geme_elementVolume( obj->area->val, obj->det->val, nQP );
obj->totalArea += obj->area->val[0];
fconn += nFP;
ERR_CheckGo( ret );
}
end_label:
fmf_freeDestroy( &faceCoor );
fmf_freeDestroy( &mtxRMS );
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 );
}
