Exemple #1
0
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 );
}
Exemple #2
0
/*!
  @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 );
}