TensorCFInterp.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _TENSORCFINTERP_H_
#define _TENSORCFINTERP_H_

#include <iostream>
#include <math.h>
#include "SPACE.H"
#include <stdlib.h>
#include "REAL.H"
#include "IntVect.H"
#include "Box.H"
#include "BaseFab.H"
#include "DisjointBoxLayout.H"
#include "LevelData.H"
#include "FArrayBox.H"
#include "QuadCFStencil.H"
#include "ProblemDomain.H"
#include "TensorFineStencilSet.H"


class TensorCFInterp
{
public:



  TensorCFInterp(
               const DisjointBoxLayout& a_fineBoxes,
               const DisjointBoxLayout* a_coarBoxes,
               Real  a_dxFine, 
               int a_refRatio,
               int a_nComp,
               const Box& a_domf);


  TensorCFInterp(
               const DisjointBoxLayout& a_fineBoxes,
               const DisjointBoxLayout* a_coarBoxes,
               Real  a_dxFine, 
               int a_refRatio,
               int a_nComp,
               const ProblemDomain& a_domf);


  void define(
              const DisjointBoxLayout& a_fineBoxes,
              const DisjointBoxLayout* a_coarBoxes,
              Real  a_dxFine, 
              int a_refRatio,
              int a_nComp,
              const Box& a_domf);


  void define(
              const DisjointBoxLayout& a_fineBoxes,
              const DisjointBoxLayout* a_coarBoxes,
              Real  a_dxFine, 
              int a_refRatio,
              int a_nComp,
              const ProblemDomain& a_domf);



  TensorCFInterp();

  ~TensorCFInterp();


  void clear();


  void coarseFineInterp(
                        LevelData<FArrayBox>& a_phif,
                        LevelData<FArrayBox>& a_tanGradf,
                        const LevelData<FArrayBox>& a_phic
                        );


  void coarseFineInterpH(
                         LevelData<FArrayBox>& a_phif,
                         LevelData<FArrayBox>& a_tanGradf
                         );


  bool isDefined() const;


protected:
  //boxes for coarse buffers
  BoxLayout m_loCoarBoxes[SpaceDim];
  BoxLayout m_hiCoarBoxes[SpaceDim];

  //fake level identifier.  
  int m_level;

  //number of components
  int m_nComp;

  //refinement ratio between levels
  int m_refRatio;

  //mesh spacing at fine level
  Real m_dxFine;

  // problem domain at fine level
  ProblemDomain m_probDomain;

  //cfstencils on low-side faces
  //lives on fine input grid layout
  LayoutData<QuadCFStencil> m_loQCFS[SpaceDim];

  //cfstencils on high-side faces
  //lives on fine input grid layout
  LayoutData<QuadCFStencil> m_hiQCFS[SpaceDim];


  LayoutData<TensorFineStencilSet> m_loFineStencilSets[SpaceDim];

  LayoutData<TensorFineStencilSet> m_hiFineStencilSets[SpaceDim];


  //buffer for coarse data at low edges of fine grids 
  BoxLayoutData<FArrayBox> m_hiCoarBuffer[SpaceDim];

  // copiers to copy data from inputCoarLayout to m_hiCoarBuffer
  Copier m_hiCoarCopiers[SpaceDim];

  //buffer for coarse data at high edges of fine grids 
  BoxLayoutData<FArrayBox> m_loCoarBuffer[SpaceDim];

  // copiers to copy data from inputCoarLayout to m_loCoarBuffer
  Copier m_loCoarCopiers[SpaceDim];

  DisjointBoxLayout m_inputFineLayout;
  DisjointBoxLayout m_inputCoarLayout;
  bool m_isDefined;

protected:

  /* Coarse / Fine interpolation operator.
     using one sided differencing
     only at a particular face
  */
  void coarseFineInterp(BaseFab<Real> & a_phif,
                        BaseFab<Real> & a_tanGradStar,
                        const BaseFab<Real> & a_phic,
                        const QuadCFStencil& a_qcfs,
                        const Side::LoHiSide a_hiorlo,
                        const int a_idir,
                        const Interval& a_variables) const;

  //get extended phi (lives next to interpivs)
  void getPhiStar(BaseFab<Real> & a_phistar, 
                  BaseFab<Real> & a_tanGradStar,
                  const BaseFab<Real> & a_phic,
                  const QuadCFStencil& a_qcfs,
                  const Side::LoHiSide a_hiorlo,
                  const int a_idir,
                  const Interval& a_variables) const;

  //interpolate over correct intvectset
  void interpOnIVS(BaseFab<Real> & a_phif,
                   const BaseFab<Real> & a_phiStar, 
                   const QuadCFStencil& a_qcfs,
                   const Side::LoHiSide a_hiorlo,
                   const int a_idir,
                   const Interval& a_variables) const;

  // compute tangential gradients
  void computeTanGrad(BaseFab<Real>& a_tanGradf,
                      const BaseFab<Real>& a_phiFine,
                      const BaseFab<Real>& a_tanGradStar,
                      const TensorFineStencilSet& a_fineStencils,
                      const QuadCFStencil& a_qcfs,
                      const Side::LoHiSide& a_hiorlo,
                      const int a_idir,
                      const Interval& a_variables) const;
};

#endif

---