BaseDomainBC.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _BASEDOMAINBC_H_
#define _BASEDOMAINBC_H_

#include "LoHiSide.H"
#include "RealVect.H"
#include "FArrayBox.H"

#include "VolIndex.H"
#include "EBCellFAB.H"
#include "EBFaceFAB.H"
#include "EBFluxFAB.H"
#include "EBISLayout.H"
#include "EBLevelGrid.H"
#include "TensorCFInterp.H"
#include "BaseBCFuncEval.H"
#include "NamespaceHeader.H"


class BaseDomainBC
{
public:

  BaseDomainBC()
  {
//     m_isBoxSet = false;
  };


  virtual ~BaseDomainBC() {};


  virtual void getFaceFlux(BaseFab<Real>&        a_faceFlux,
                           const BaseFab<Real>&  a_phi,
                           const RealVect&       a_probLo,
                           const RealVect&       a_dx,
                           const int&            a_idir,
                           const Side::LoHiSide& a_side,
                           const DataIndex&      a_dit,
                           const Real&           a_time,
                           const bool&           a_useHomogeneous) = 0;


  virtual int whichBC(int                  a_idir,
                      Side::LoHiSide       a_side)
  {
    return -777;
  }

  virtual void getFaceFlux(BaseFab<Real>&        a_faceFlux,
                           const Real&           a_betaFace,
                           const BaseFab<Real>&  a_phi,
                           const RealVect&       a_probLo,
                           const RealVect&       a_dx,
                           const int&            a_idir,
                           const Side::LoHiSide& a_side,
                           const DataIndex&      a_dit,
                           const Real&           a_time,
                           const bool&           a_useHomogeneous)
  {
    getFaceFlux(a_faceFlux,
                a_phi,
                a_probLo,
                a_dx,
                a_idir,
                a_side,
                a_dit,
                a_time,
                a_useHomogeneous);
  }



  virtual void getFaceFlux(Real&                 a_faceFlux,
                           const VolIndex&       a_vof,
                           const int&            a_comp,
                           const EBCellFAB&      a_phi,
                           const RealVect&       a_probLo,
                           const RealVect&       a_dx,
                           const int&            a_idir,
                           const Side::LoHiSide& a_side,
                           const DataIndex&      a_dit,
                           const Real&           a_time,
                           const bool&           a_useHomogeneous) = 0;


  virtual void getFaceFlux(Real&                 a_faceFlux,
                           const VolIndex&       a_vof,
                           const int&            a_comp,
                           const Real &          a_betaFace,
                           const EBCellFAB&      a_phi,
                           const RealVect&       a_probLo,
                           const RealVect&       a_dx,
                           const int&            a_idir,
                           const Side::LoHiSide& a_side,
                           const DataIndex&      a_dit,
                           const Real&           a_time,
                           const bool&           a_useHomogeneous)
  {
    getFaceFlux(a_faceFlux,
                a_vof,
                a_comp,
                a_phi,
                a_probLo,
                a_dx,
                a_idir,
                a_side,
                a_dit,
                a_time,
                a_useHomogeneous);
  }


  virtual void getFaceGradPhi(Real&                 a_faceFlux,
                              const FaceIndex&      a_face,
                              const int&            a_comp,
                              const EBCellFAB&      a_phi,
                              const RealVect&       a_probLo,
                              const RealVect&       a_dx,
                              const int&            a_idir,
                              const Side::LoHiSide& a_side,
                              const DataIndex&      a_dit,
                              const Real&           a_time,
                              const bool&           a_useAreaFrac,
                              const RealVect&       a_centroid,
                              const bool&           a_useHomogeneous) = 0;


  virtual void getFaceGradPhi(Real&                 a_faceFlux,
                              const FaceIndex&      a_face,
                              const int&            a_comp,
                              const Real&           a_betaFace,
                              const EBCellFAB&      a_phi,
                              const RealVect&       a_probLo,
                              const RealVect&       a_dx,
                              const int&            a_idir,
                              const Side::LoHiSide& a_side,
                              const DataIndex&      a_dit,
                              const Real&           a_time,
                              const bool&           a_useAreaFrac,
                              const RealVect&       a_centroid,
                              const bool&           a_useHomogeneous)
  {
    getFaceGradPhi(a_faceFlux,
                   a_face,
                   a_comp,
                   a_phi,
                   a_probLo,
                   a_dx,
                   a_idir,
                   a_side,
                   a_dit,
                   a_time,
                   a_useAreaFrac,
                   a_centroid,
                   a_useHomogeneous);
  }

  virtual void enforceFaceVel(LevelData<EBFluxFAB>&    a_velocity,
                              const DisjointBoxLayout& a_grids,
                              const EBISLayout&        a_ebisl,
                              const ProblemDomain&     a_domain,
                              const RealVect&          a_dx,
                              const Real&              a_time,
                              const RealVect&          a_origin,
                              const bool&              a_doDivFreeOutflow);


  virtual void getFaceVel(Real&                 a_faceFlux,
                          const FaceIndex&      a_vof,
                          const EBFluxFAB&      a_vel,
                          const RealVect&       a_probLo,
                          const RealVect&       a_dx,
                          const int&            a_idir,
                          const int&            a_icomp,
                          const Real&           a_time,
                          const Side::LoHiSide& a_side,
                          const bool&           a_doDivFreeOutflow) = 0;

//   void setCurrentBox(const Box& a_box)
//   {
//     m_currentBox = a_box;
//     m_isBoxSet = true;
//   }

// protected:
//   Box m_currentBox;
//   bool m_isBoxSet;

};


class ViscousBaseDomainBC: public BaseDomainBC
{
public:

  ViscousBaseDomainBC()
  {
    m_coefSet  = false;
    m_value = 12345.6789;
    m_func = RefCountedPtr<BaseBCFuncEval>();
    m_isFunction = false;
  }

  virtual ~ViscousBaseDomainBC()
  {
  }

  void setCoef(EBLevelGrid                         &  a_eblg,
               Real                                &  a_beta,
               RefCountedPtr<LevelData<EBFluxFAB> >&  a_eta,
               RefCountedPtr<LevelData<EBFluxFAB> >&  a_lambda)
  {
    m_coefSet = true;
    m_eblg    = a_eblg;
    m_beta    = a_beta;
    m_eta     = a_eta;
    m_lambda  = a_lambda;
  }

  virtual void getFaceVel(Real&                 a_faceFlux,
                          const FaceIndex&      a_vof,
                          const EBFluxFAB&      a_vel,
                          const RealVect&       a_probLo,
                          const RealVect&       a_dx,
                          const int&            a_idir,
                          const int&            a_icomp,
                          const Real&           a_time,
                          const Side::LoHiSide& a_side,
                          const bool&           a_doDivFreeOutflow)
  {
    //projection thingy does not apply here
    MayDay::Error();
  }
  virtual void getFaceGradPhi(Real&                 a_faceFlux,
                              const FaceIndex&      a_face,
                              const int&            a_comp,
                              const EBCellFAB&      a_phi,
                              const RealVect&       a_probLo,
                              const RealVect&       a_dx,
                              const int&            a_idir,
                              const Side::LoHiSide& a_side,
                              const DataIndex&      a_dit,
                              const Real&           a_time,
                              const bool&           a_useAreaFrac,
                              const RealVect&       a_centroid,
                              const bool&           a_useHomogeneous)
  {
    //projection thingy does not apply here
    MayDay::Error();
  }

  virtual void setValue(Real a_value)
  {
    m_value = a_value;
    m_func = RefCountedPtr<BaseBCFuncEval>();

    m_isFunction = false;
  }



  virtual void setFunction(RefCountedPtr<BaseBCFuncEval> a_func)
  {
    m_value = 12345.6789;
    m_func = a_func;

    m_isFunction = true;
  }

  void getFluxFromGrad(BaseFab<Real>&   a_flux,
                       const FArrayBox& a_grad,
                       const DataIndex& a_dit,
                       const int&       a_idir);

protected:
  bool m_isFunction;


  Real m_value;
  RefCountedPtr<BaseBCFuncEval> m_func;

  Real                                  m_beta;
  bool                                  m_coefSet;
  EBLevelGrid                           m_eblg;
  RefCountedPtr<LevelData<EBFluxFAB> >  m_eta;
  RefCountedPtr<LevelData<EBFluxFAB> >  m_lambda;
};


class ConductivityBaseDomainBC: public BaseDomainBC
{
public:

  ConductivityBaseDomainBC()
  {
    m_coefSet  = false;
  }

  virtual ~ConductivityBaseDomainBC()
  {
  }


  void setCoef(EBLevelGrid                         &  a_eblg,
               Real                                &  a_beta,
               RefCountedPtr<LevelData<EBFluxFAB> >&  a_bcoef)
  {
    m_coefSet = true;
    m_eblg    = a_eblg;
    m_beta    = a_beta;
    m_bcoef   = a_bcoef;
  }


protected:
  bool                                  m_coefSet;
  EBLevelGrid                           m_eblg;
  Real                                  m_beta;
  RefCountedPtr<LevelData<EBFluxFAB> >  m_bcoef;
};

class BaseDomainBCFactory
{
public:

  BaseDomainBCFactory() {};


  virtual ~BaseDomainBCFactory() {};


  virtual BaseDomainBC* create(const ProblemDomain& a_domain,
                               const EBISLayout&    a_layout,
                               const RealVect&      a_dx) = 0;
};
#include "NamespaceFooter.H"
#endif

---