TensorOp.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 _TENSOROP_H_
#define _TENSOROP_H_

#include <iostream>
#include <cmath>
#include "SPACE.H"
#include <cstdlib>
#include <REAL.H>
#include <IntVect.H>
#include <Box.H>
#include <DisjointBoxLayout.H>
#include <LevelData.H>
#include <BaseFab.H>
#include "FArrayBox.H"
#include "FluxBox.H"
#include "GhostBC.H"
#include "LevelOp.H"
#include "TensorCFInterp.H"
#include "CFIVS.H"
#include "Copier.H"
#include "BaseBottomSmoother.H"


class TensorOp: public LevelOp
{
public:


  virtual LevelOp* new_levelop() const;

  virtual bool isDefined() const;


  void define(
              const DisjointBoxLayout& Ba,
              const DisjointBoxLayout* base_ba,
              Real  DxLevel, 
              int refratio,
              const Box& domf,
              bool a_homogeneousOnly=false,
              int ncomp = 1);


  void define(
              const DisjointBoxLayout& Ba,
              const DisjointBoxLayout* base_ba,
              Real  DxLevel, 
              int refratio,
              const ProblemDomain& domf,
              bool a_homogeneousOnly=false,
              int ncomp = 1);


  void define(
              const LevelOp* opfine,
              int refratio);

  TensorOp();

  ~TensorOp();


  void smooth(
              LevelData<FArrayBox>& a_phi,
              const LevelData<FArrayBox>& a_rhs);

  


  virtual void levelPreconditioner(
                                   LevelData<FArrayBox>& a_phihat,
                                   const LevelData<FArrayBox>& a_rhshat
                                   );


  void applyOpI(
                LevelData<FArrayBox>& a_phi,
                const LevelData<FArrayBox>* a_phiCoarse,
                LevelData<FArrayBox>& a_LOfPhi);


  void applyOpIcfHphys(
                       LevelData<FArrayBox>& a_phi,
                       const LevelData<FArrayBox>* a_phiCoarse,
                       LevelData<FArrayBox>& a_LOfPhi);


  void applyOpH(
                LevelData<FArrayBox>& a_phi,
                LevelData<FArrayBox>& a_LOfPhi);


  void CFInterp(LevelData<FArrayBox>& a_phi,
                const LevelData<FArrayBox>& a_phiCoarse
                );


  void applyOpHcfIphys(
                       LevelData<FArrayBox>& a_phi,
                       LevelData<FArrayBox>& a_lOfPhi);



  void homogeneousCFInterp(LevelData<FArrayBox>& a_phi);

  void setDomainGhostBC(const DomainGhostBC& a_dombcin);

  void setTanGradBC(const DomainGhostBC& a_dombcIn);

  void setBottomSmoother(const BaseBottomSmoother& a_bottomSmoother);


  void
  homogeneousCFInterpPhi(LevelData<FArrayBox>& a_phif, 
                         const DataIndex& a_datInd, 
                         int a_idir, 
                         Side::LoHiSide a_hiorlo);


  void homogeneousCFInterpTanGrad(LevelData<FArrayBox>& a_tanGrad,
                                  const LevelData<FArrayBox>& a_phi,
                                  const DataIndex& a_datInd,
                                  int a_idir,
                                  Side::LoHiSide a_hiorlo);


  void bottomSmoother(
                      LevelData<FArrayBox>& a_phi,
                      const LevelData<FArrayBox>& a_rhs);


  void getFlux(
               FArrayBox& flux, 
               const FArrayBox& a_data, 
               const DataIndex& a_datInd,
               int a_dir);

  virtual void setConvergenceMetric(Real a_metric, int a_comp);


  const LevelData<FArrayBox>& getTanGrad() const;

protected:

  // boundary conditons
  DomainGhostBC m_domghostbc;

  // boundary conditions for tangential component of gradient
  DomainGhostBC m_tangradbc;

  //domain of fine grid
  ProblemDomain m_domain;

  //the grids at the current level
  DisjointBoxLayout m_grids;

  // Copier object that knows how to perform exchange operations on 
  // LevelData objects defined on m_grids
  Copier m_exchangeCopier;

  /* DisjointBoxLayout for next coarser level
     this is == NULL if there is no coarser level */
  DisjointBoxLayout m_baseBA;

  // number of components
  int m_ncomp;

  // refinement ratio between this and the next coarser level
  int m_refRatio;

  //mesh spacing at this level
  Real m_dxLevel;

  //mesh spacing at next coarser level
  Real m_dxCrse;

  /*
    coarse-fine information between this level
    and the next coarser level
  */
  TensorCFInterp m_quadCFI;

   
  /* bottom smoother object
   */
  BaseBottomSmoother* m_bottom_smoother_ptr;

  //contains tangential gradient info
  LevelData<FArrayBox> m_tanGrad;

  //has full define function been called?
  bool m_isDefined;

  //has bc been defined?
  bool m_isBCDefined;

  // has bc for tangential gradients been defined?
  bool m_isGradBCDefined;

  //is inhomogeneous CF interpolation possible?
  bool m_ihcfiEnabled;

  LayoutData<CFIVS> m_loCFIVS[SpaceDim];
  LayoutData<CFIVS> m_hiCFIVS[SpaceDim];

  // will need these to do tangential gradient computations
  LayoutData<TensorFineStencilSet> m_hiTanStencilSets[SpaceDim];
  LayoutData<TensorFineStencilSet> m_loTanStencilSets[SpaceDim];

private:
  //internally useful functions
  void
  levelGSRB(
            LevelData<FArrayBox>& a_phi, 
            const LevelData<FArrayBox>& a_rhs);
  void
  interpPhiOnIVS(
                 LevelData<FArrayBox>& a_phif, 
                 const FArrayBox& a_phistar, 
                 const DataIndex& dFine,
                 const int a_idir,
                 const Side::LoHiSide a_hiorlo,
                 const IntVectSet& a_interpIVS);
  
  void
  computeFaceDiv(LevelData<FluxBox>& a_div,
                 const LevelData<FArrayBox>& a_vel,
                 const LevelData<FArrayBox>& a_tanGrad);

  void
  computeFaceDiv(FArrayBox& a_div,
                 const FArrayBox& a_vel,
                 const FArrayBox& a_tanGrad,
                 const DataIndex& a_dataInd,
                 int faceDir);

  // computes tangential gradients of a_vel and stores in m_tanGrad
  void
  computeTanGradInterior(const LevelData<FArrayBox>& a_vel);

  // computes tangential gradients of a_vel and stores in m_tanGrad
  void
  computeTanGradInterior(const FArrayBox& a_vel,
                         const DataIndex& a_dataInd);


  // computes gradient of a_vel in a_gradDir and stores in m_tanGrad
  void
  computeTanGradInterior(const FArrayBox& a_vel,
                         const DataIndex& a_dataInd,
                         int a_gradDir);

  void clearMemory();

  void setDefaultValues();

};

#endif

---