C++ (Cpp) fmfc_mulC 예제들

예제 #1

파일: termsBiot.c 프로젝트: AshitaPrasad/sfepy

/*!
  @par Revision history:
  - c: 05.03.2008, r: 05.03.2008
*/
int32 d_biot_div( FMField *out, float64 coef, FMField *state, FMField *strain,
		  FMField *mtxD, Mapping *vg )
{
  int32 ii, nQP, ret = RET_OK;
  FMField *dtgu = 0, *pftdtgu = 0;

  nQP = vg->bfGM->nLev;

/*   fmf_print( mtxD, stdout, 0 ); */

  fmf_createAlloc( &dtgu, 1, nQP, 1, 1 );
  fmf_createAlloc( &pftdtgu, 1, nQP, 1, 1 );

  for (ii = 0; ii < out->nCell; ii++) {
    FMF_SetCell( out, ii );
    FMF_SetCell( mtxD, ii );
    FMF_SetCell( vg->det, ii );
    FMF_SetCell( state, ii );
    FMF_SetCell( strain, ii );

    fmf_mulATB_nn( dtgu, mtxD, strain );
    fmf_mulATB_nn( pftdtgu, state, dtgu );
    fmf_sumLevelsMulF( out, pftdtgu, vg->det->val );
    ERR_CheckGo( ret );
  }

  // E.g. 1/dt.
  fmfc_mulC( out, coef );

 end_label:
  fmf_freeDestroy( &dtgu );
  fmf_freeDestroy( &pftdtgu );

  return( ret );
}

예제 #2

파일: termsBiot.c 프로젝트: AshitaPrasad/sfepy

/*!
  @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( &gtd, 1, nQP, dim * nEPU, 1 );
    fmf_createAlloc( &gtdf, 1, nQP, dim * nEPU, nEP );
  } else {
    int32 sym = (dim + 1) * dim / 2;
    fmf_createAlloc( &dfp, 1, nQP, sym, 1 );
    fmf_createAlloc( &gtdfp, 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( &gtd );
    fmf_freeDestroy( &gtdf );
  } else {
    fmf_freeDestroy( &dfp );
    fmf_freeDestroy( &gtdfp );
  }

  return( ret );
}

예제 #3

파일: termsAdjointNavierStokes.c 프로젝트: mikegraham/sfepy

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

예제 #4

파일: termsLaplace.c 프로젝트: olivierverdier/sfepy

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

예제 #5

파일: termsLinElasticity.c 프로젝트: taldcroft/sfepy

/*!
  @par Revision history:
  - 02.03.2007, c
*/
int32 d_lin_elastic( FMField *out, float64 coef, FMField *strainV,
		     FMField *strainU, FMField *mtxD, VolumeGeometry *vg )
{
  int32 ii, dim, sym, nQP, nEP, ret = RET_OK;
  FMField *std = 0, *stds = 0;

  nQP = vg->bfGM->nLev;
  nEP = vg->bfGM->nCol;
  dim = vg->bfGM->nRow;
  sym = (dim + 1) * dim / 2;

  fmf_createAlloc( &std, 1, nQP, 1, sym );
  fmf_createAlloc( &stds, 1, nQP, 1, 1 );

  for (ii = 0; ii < out->nCell; ii++) {
    FMF_SetCell( out, ii );
    FMF_SetCell( mtxD, ii );
    FMF_SetCell( vg->det, ii );
    FMF_SetCell( strainV, ii );
    FMF_SetCell( strainU, ii );

    fmf_mulATB_nn( std, strainV, mtxD );
    fmf_mulAB_nn( stds, std, strainU );
    fmf_sumLevelsMulF( out, stds, vg->det->val );

    ERR_CheckGo( ret );
  }

  // E.g. 1/dt.
  fmfc_mulC( out, coef );

 end_label:
  fmf_freeDestroy( &std );
  fmf_freeDestroy( &stds );

  return( ret );
}

예제 #6

파일: termsBiot.c 프로젝트: AshitaPrasad/sfepy

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

예제 #7

파일: termsLinElasticity.c 프로젝트: taldcroft/sfepy

/*!
  @par Revision history:
  - 03.08.2006, c
  - 29.11.2006
*/
int32 dw_lin_elastic( FMField *out, float64 coef, FMField *strain,
		      FMField *mtxD, VolumeGeometry *vg,
		      int32 isDiff )
{
  int32 ii, dim, sym, nQP, nEP, ret = RET_OK;
  FMField *stress = 0;
  FMField *res = 0, *gtd = 0, *gtdg = 0;

  nQP = vg->bfGM->nLev;
  nEP = vg->bfGM->nCol;
  dim = vg->bfGM->nRow;
  sym = (dim + 1) * dim / 2;

/*       fmf_print( mtxD, stdout, 0 ); */
/*   output( "%d %d %d %d %d %d\n", offset, nEl, nEP, nQP, dim, elList_nRow ); */
  if (isDiff) {
    fmf_createAlloc( &gtd, 1, nQP, nEP * dim, sym );
    fmf_createAlloc( &gtdg, 1, nQP, nEP * dim, nEP * dim );

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

      form_sdcc_actOpGT_M3( gtd, vg->bfGM, mtxD );
      form_sdcc_actOpG_RM3( gtdg, gtd, vg->bfGM );
      fmf_sumLevelsMulF( out, gtdg, vg->det->val );

      ERR_CheckGo( ret );
    }
  } else {
    fmf_createAlloc( &stress, 1, nQP, sym, 1 );
    fmf_createAlloc( &res, 1, nQP, dim * nEP, 1 );

    for (ii = 0; ii < out->nCell; ii++) {
      FMF_SetCell( out, ii );
      FMF_SetCell( mtxD, ii );
      FMF_SetCell( vg->bfGM, ii );
      FMF_SetCell( vg->det, ii );
      FMF_SetCell( strain, ii );

      fmf_mulAB_nn( stress, mtxD, strain );
      form_sdcc_actOpGT_VS3( res, vg->bfGM, stress );
      fmf_sumLevelsMulF( out, res, vg->det->val );
      ERR_CheckGo( ret );
    }
  }

  // E.g. 1/dt.
  fmfc_mulC( out, coef );

 end_label:
  if (isDiff) {
    fmf_freeDestroy( &gtd );
    fmf_freeDestroy( &gtdg );
  } else {
    fmf_freeDestroy( &res ); 
    fmf_freeDestroy( &stress ); 
  }

  return( ret );
}

예제 #8

파일: termsMass.c 프로젝트: certik/sfepy

/*!
  @par Revision history:
  - 21.11.2006, c
*/
int32 dw_mass( FMField *out, float64 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, *fu = 0, *ftfu = 0, *ftf1 = 0, *ftf = 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 * dim, nEP * dim );
    fmf_createAlloc( &ftf1, 1, nQP, nEP, nEP );

    fmf_mulATB_nn( ftf1, bf, bf );
    bf_buildFTF( ftf, ftf1 );

/*     fmf_print( bf, stdout, 0 ); */
/*     fmf_print( ftf1, stdout, 0 ); */
/*     fmf_print( ftf, stdout, 0 ); */
/*     sys_pause(); */

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

      FMF_SetCell( out, ii );
      FMF_SetCell( vg->det, iel );

      fmf_sumLevelsMulF( out, ftf, vg->det->val );
/*       fmf_print( out, stdout, 0 ); */
/*       sys_pause(); */

      ERR_CheckGo( ret );
    }
  } else {
    state->val = FMF_PtrFirst( state ) + offset;

    fmf_createAlloc( &st, 1, 1, dim, nEP );
    fmf_createAlloc( &fu, 1, nQP, dim, 1 );
    fmf_createAlloc( &ftfu, 1, nQP, dim * nEP, 1 );

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

      FMF_SetCell( out, ii );
      FMF_SetCell( vg->det, iel );

      ele_extractNodalValuesDBD( st, state, conn + nEP * iel );

      bf_act( fu, bf, st );
      bf_actt( ftfu, bf, fu );
      fmf_sumLevelsMulF( out, ftfu, vg->det->val );

      ERR_CheckGo( ret );
    }
  }

  // E.g. 1/dt.
  fmfc_mulC( out, coef );

 end_label:
  if (isDiff) {
    fmf_freeDestroy( &ftf1 );
    fmf_freeDestroy( &ftf );
  } else {
    fmf_freeDestroy( &st ); 
    fmf_freeDestroy( &fu ); 
    fmf_freeDestroy( &ftfu ); 
  }

  return( ret );
}