C++ (Cpp) fmf_mulAF Examples

Example #1

File: terms_diffusion.c Project: LeiDai/sfepy

/*!
  @par Revision history:
  - 28.11.2005, c
  - 09.12.2005
*/
int32 dw_laplace( FMField *out, FMField *grad,
		  FMField *coef, Mapping *vg,
		  int32 isDiff )
{
  int32 ii, dim, nQP, nEP, ret = RET_OK;
  FMField *gtg = 0, *gtgu = 0;

  nQP = vg->bfGM->nLev;
  nEP = vg->bfGM->nCol;
  dim = vg->bfGM->nRow;


  if (isDiff) {
    fmf_createAlloc( &gtg, 1, nQP, nEP, nEP );
  } else {
    fmf_createAlloc( &gtgu, 1, nQP, nEP, 1 );
  }

  for (ii = 0; ii < out->nCell; ii++) {
    FMF_SetCell( out, ii );
    FMF_SetCell( vg->bfGM, ii );
    FMF_SetCell( vg->det, ii );
    if (coef->nCell > 1)
      FMF_SetCell( coef, ii );

    if (isDiff) {
      laplace_build_gtg( gtg, vg->bfGM );
      fmf_mulAF( gtg, gtg, coef->val );
      fmf_sumLevelsMulF( out, gtg, vg->det->val );
    } else {
      FMF_SetCell( grad, ii );
      laplace_act_gt_m( gtgu, vg->bfGM, grad );
      fmf_mulAF( gtgu, gtgu, coef->val );
      fmf_sumLevelsMulF( out, gtgu, vg->det->val );
    }
    ERR_CheckGo( ret );
  }

 end_label:
  if (isDiff) {
    fmf_freeDestroy( &gtg );
  } else {
    fmf_freeDestroy( &gtgu );
  }

  return( ret );
}

Example #2

File: termsMass.c Project: renatocoutinho/sfepy

/*!
  @par Revision history:
  - 01.02.2008, c
*/
int32 dw_mass_scalar( FMField *out, FMField *coef,
		      FMField *state, FMField *bf, VolumeGeometry *vg,
		      int32 isDiff )
{
  int32 ii, dim, nQP, nEP, ret = RET_OK;
  FMField *ftfp = 0, *ftf = 0, *cftf = 0;

  nQP = vg->bfGM->nLev;
  nEP = vg->bfGM->nCol;
  dim = vg->bfGM->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 < out->nCell; ii++) {
      FMF_SetCell( out, ii );
      FMF_SetCell( vg->det, ii );
      if (coef->nCell > 1) {
	FMF_SetCell( coef, ii );
      }

      fmf_mulAF( cftf, ftf, coef->val );
      fmf_sumLevelsMulF( out, cftf, vg->det->val );

      ERR_CheckGo( ret );
    }
  } else {
    fmf_createAlloc( &ftfp, 1, nQP, nEP, 1 );

    for (ii = 0; ii < out->nCell; ii++) {
      FMF_SetCell( out, ii );
      FMF_SetCell( state, ii );
      FMF_SetCell( vg->det, ii );
      if (coef->nCell > 1) {
	FMF_SetCell( coef, ii );
      }

      bf_actt( ftfp, bf, state );
      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( &ftfp );
  }

  return( ret );
}

Example #3

File: terms_dot.c Project: Gkdnz/sfepy

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

Example #4

File: termsLaplace.c Project: olivierverdier/sfepy

int32 d_laplace( FMField *out, FMField *gradP1, FMField *gradP2,
		 FMField *coef, VolumeGeometry *vg,
		 int32 *elList, int32 elList_nRow )
{
  int32 ii, iel, dim, nQP, ret = RET_OK;
  FMField *dgp2 = 0, *gp1tdgp2 = 0;

  nQP = vg->bfGM->nLev;
  dim = vg->bfGM->nRow;

  fmf_createAlloc( &dgp2, 1, nQP, dim, 1 );
  fmf_createAlloc( &gp1tdgp2, 1, nQP, 1, 1 );

  for (ii = 0; ii < elList_nRow; ii++) {
    iel = elList[ii];

    FMF_SetCell( out, ii );
    FMF_SetCell( vg->det, iel );
    FMF_SetCell( gradP1, iel );
    FMF_SetCell( gradP2, iel );
    if (coef->nCell > 1) {
      FMF_SetCell( coef, ii );
    }

    fmf_mulAF( dgp2, gradP2, coef->val );
    fmf_mulATB_nn( gp1tdgp2, gradP1, dgp2 );
    fmf_sumLevelsMulF( out, gp1tdgp2, vg->det->val );

    ERR_CheckGo( ret );
  }

 end_label:
  fmf_freeDestroy( &dgp2 );
  fmf_freeDestroy( &gp1tdgp2 );

  return( ret );
}

Example #5

File: termsMass.c Project: certik/sfepy

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

Example #6

File: termsLaplace.c Project: olivierverdier/sfepy

/*!
  @par Revision history:
  - 28.11.2005, c
  - 09.12.2005
*/
int32 dw_laplace( FMField *out, FMField *state, int32 offset,
		  FMField *coef, 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, *gtg = 0, *gu = 0, *gtgu = 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;

  if (isDiff) {
    fmf_createAlloc( &gtg, 1, nQP, nEP, nEP );
  } else {
    fmf_createAlloc( &st, 1, 1, nEP, 1 );
    fmf_createAlloc( &gu, 1, nQP, dim, 1 );
    fmf_createAlloc( &gtgu, 1, nQP, nEP, 1 );
  }

  for (ii = 0; ii < elList_nRow; ii++) {
    iel = elList[ii];

/*     output( "%d %d\n", ii, iel ); */
    FMF_SetCell( out, ii );
    FMF_SetCell( coef, ii );
    FMF_SetCell( vg->bfGM, iel );
    FMF_SetCell( vg->det, iel );

/*     fmf_print( coef, stdout, 0 ); */
/*     fmf_print( vg->bfGM, stdout, 0 ); */
/*     fmf_print( vg->det, stdout, 0 ); */

    if (isDiff) {
      laplace_build_gtg( gtg, vg->bfGM );
      fmf_mulAF( gtg, gtg, coef->val );
      fmf_sumLevelsMulF( out, gtg, vg->det->val );
/*       fmf_print( out, stdout, 0 ); */
/*       sys_pause(); */
    } else {
      ele_extractNodalValuesNBN( st, state, conn + nEP * iel );
/*       build_gtg( gtg, vg->bfGM ); ERR_CheckGo( ret ); */
/*       fmf_mulAB_n1( gtgu, gtg, stv ); */
/*       fmf_print( gtgu, stdout, 0 ); */

      laplace_act_g_m( gu, vg->bfGM, st );
      laplace_act_gt_m( gtgu, vg->bfGM, gu );
      fmf_mulAF( gtgu, gtgu, coef->val );
      fmf_sumLevelsMulF( out, gtgu, vg->det->val );

/*       fmf_print( stv, stdout, 0 ); */
/*       fmf_print( gu, stdout, 0 ); */
/*       fmf_print( gtgu, stdout, 0 ); */
/*       fmf_print( out, stdout, 0 ); */
/*       sys_pause(); */
    }
    ERR_CheckGo( ret );
  }

 end_label:
  if (isDiff) {
    fmf_freeDestroy( &gtg ); 
  } else {
    fmf_freeDestroy( &st ); 
    fmf_freeDestroy( &gu ); 
    fmf_freeDestroy( &gtgu ); 
  }

  return( ret );
}