C++ (Cpp) EBCellFAB::getMultiValuedFAB Examples

Example #1

File: EBStenVarCoef.cpp Project: dtgraves/EBAMRCNS

void
EBStenVarCoef::
cache(const EBCellFAB& a_phi, int a_ivar)
{
  CH_assert(a_phi.getSingleValuedFAB().box()   == m_grownBox);
  const Real* singleValuedPtrPhi =    a_phi.getSingleValuedFAB().dataPtr(a_ivar);
  const Real*  multiValuedPtrPhi =     a_phi.getMultiValuedFAB().dataPtr(a_ivar);

  for (int isrc = 0; isrc < m_sourTerms.size(); isrc++)
    {
      //debugging hook
      //const VolIndex& srcVoF = m_srcVoFs[isrc];
      if (m_sourTerms[isrc].multiValued)
        {
          m_cache[isrc] = *(multiValuedPtrPhi + m_sourTerms[isrc].offset);
        }
      else
        {
          m_cache[isrc] = *(singleValuedPtrPhi + m_sourTerms[isrc].offset);
        }
    }
}

Example #2

File: EBStenVarCoef.cpp Project: dtgraves/EBAMRCNS

void
EBStenVarCoef::
uncache(EBCellFAB& a_phi, int a_ivar) const
{
  CH_assert(a_phi.getSingleValuedFAB().box()    == m_grownBox);

  Real* singleValuedPtrPhi =    a_phi.getSingleValuedFAB().dataPtr(a_ivar);
  Real*  multiValuedPtrPhi =     a_phi.getMultiValuedFAB().dataPtr(a_ivar);
  Real* phiPtr = NULL;

  for (int isrc = 0; isrc < m_sourTerms.size(); isrc++)
    {
      if (m_sourTerms[isrc].multiValued)
        {
          phiPtr  = multiValuedPtrPhi + m_sourTerms[isrc].offset;
        }
      else
        {
          phiPtr  = singleValuedPtrPhi + m_sourTerms[isrc].offset;
        }

      *phiPtr = m_cache[isrc];
    }
}

Example #3

File: EBStenVarCoef.cpp Project: dtgraves/EBAMRCNS

void
EBStenVarCoef::
relax(EBCellFAB&  a_phi,
      const EBCellFAB&  a_rhs,
      const EBCellFAB&  a_alphaWeight,
      const EBCellFAB&  a_betaWeight,
      const EBCellFAB&  a_lambda,
      Real a_alpha, Real a_beta) const
{
  CH_TIME("EBStenVarCoef::relax");
  CH_assert(a_rhs.getSingleValuedFAB().box()         == m_grownBox);
  CH_assert(a_phi.getSingleValuedFAB().box()         == m_grownBox);
  CH_assert(a_alphaWeight.getSingleValuedFAB().box() == m_grownBox);
  CH_assert(a_betaWeight.getSingleValuedFAB().box()  == m_grownBox);
  CH_assert(a_lambda.getSingleValuedFAB().box()      == m_grownBox);


  Real*       singleValuedPtrPhi =    a_phi.getSingleValuedFAB().dataPtr(0);
  const Real* singleValuedPtrRhs =    a_rhs.getSingleValuedFAB().dataPtr(m_destVar);
  Real*       multiValuedPtrPhi  =     a_phi.getMultiValuedFAB().dataPtr(0);
  const Real* multiValuedPtrRhs  =     a_rhs.getMultiValuedFAB().dataPtr(m_destVar);

  const Real* singleValuedPtrAlp =    a_alphaWeight.getSingleValuedFAB().dataPtr(0);
  const Real*  multiValuedPtrAlp =    a_alphaWeight. getMultiValuedFAB().dataPtr(0);

  const Real* singleValuedPtrBet =      a_betaWeight.getSingleValuedFAB().dataPtr(0);
  const Real*  multiValuedPtrBet =      a_betaWeight. getMultiValuedFAB().dataPtr(0);

  const Real* singleValuedPtrLam =         a_lambda.getSingleValuedFAB().dataPtr(0);
  const Real*  multiValuedPtrLam =         a_lambda. getMultiValuedFAB().dataPtr(0);

  //plo is different from phi because of destvar
  //phi is for stencil evaluation.  plo is for the local value at this variable
  Real*        multiValuedPtrPlo =    a_phi. getMultiValuedFAB().dataPtr(m_destVar);
  Real*       singleValuedPtrPlo =    a_phi.getSingleValuedFAB().dataPtr(m_destVar);

  for (int isrc = 0; isrc < m_stencil.size(); isrc++)
    {

      //const VolIndex& srcVoF = m_srcVoFs[isrc];
      Real*       phiPtr  = NULL;
      const Real* rhsPtr  = NULL;
      const Real* alpPtr  = NULL;
      const Real* betPtr  = NULL;
      const Real* lamPtr  = NULL;
      if (m_sourTerms[isrc].multiValued)
        {
          rhsPtr  = multiValuedPtrRhs + m_sourTerms[isrc].offset;
          phiPtr  = multiValuedPtrPlo + m_sourTerms[isrc].offset;
          alpPtr  = multiValuedPtrAlp + m_sourTerms[isrc].offset;
          betPtr  = multiValuedPtrBet + m_sourTerms[isrc].offset;
          lamPtr  = multiValuedPtrLam + m_sourTerms[isrc].offset;
        }
      else
        {
          rhsPtr  = singleValuedPtrRhs + m_sourTerms[isrc].offset;
          phiPtr  = singleValuedPtrPlo + m_sourTerms[isrc].offset;
          alpPtr  = singleValuedPtrAlp + m_sourTerms[isrc].offset;
          betPtr  = singleValuedPtrBet + m_sourTerms[isrc].offset;
          lamPtr  = singleValuedPtrLam + m_sourTerms[isrc].offset;
        }

      Real&       phi         = *phiPtr;
      const Real& lambda      = *lamPtr;
      const Real& rhs         = *rhsPtr;
      const Real& alphaWeight = *alpPtr;
      const Real&  betaWeight = *betPtr;


      Real lph =  0.;
      const varcsten_t& stenpt = m_stencil[isrc];
      //single-valued
      for (int isingle = 0; isingle < stenpt.single.size(); isingle++)
        {
          const int & offset = stenpt.single[isingle].offset;
          const Real& phiVal = *(singleValuedPtrPhi + offset);
          const Real& weight = stenpt.single[isingle].weight;
          lph += phiVal*weight;
        }
      //multi-valued
      for (int imulti = 0; imulti < stenpt.multi.size(); imulti++)
        {
          const int & offset = stenpt.multi[imulti].offset;
          const Real& phiVal = *(multiValuedPtrPhi + offset);
          const Real& weight = stenpt.multi[imulti].weight;
          lph += phiVal*weight;
        }
      //at this point lph holds divF.  add in identity terms
      //and multiply by factors
      lph = a_alpha*alphaWeight*phi + a_beta*betaWeight*lph;

      phi = phi + lambda*(rhs - lph);
    }
}